raif 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232a25681c254ff213ce9565506bffc805df041361e145016eee17f0ca3514f3
-  data.tar.gz: 24c54f8c2d5ea95664a55a57b7ed8c3e22d3040f79f28311eb60083aa2d9f47e
+  metadata.gz: 93d75d28d64da2a5559de740890291cb3a125d981bb58aa56ff4c45be0169954
+  data.tar.gz: 9f3ca2e5142f43be17c9fe27e3572cd08a4241e72d6e43893b74e6ba954169ae
 SHA512:
-  metadata.gz: c07aa30bcc9b040f75876124fec474bf48f13222ccbb053b7f0dba2313dbd459965d37fcd2b305d399dd503495cfadc2ca4f2b5c8e48f604528f6555d46e404e
-  data.tar.gz: 9d33cca29d90ed9dda3d7fd93c988b4b48999db4394be62044350648f11083ed03138201f76bb16569fbad6c61c2ff8b917af47d1f4a6e687c527bb9cd32b4b0
+  metadata.gz: 90726f18f49a312f0e8d2ceb3913c1bb45c50ad237f0fceeefa825e28374214a8c61ae84c4a83e6d3188a27adea3dc0162001792d867babadca5e30f5f736398
+  data.tar.gz: e053003fd9c510509cbc749d5f20d9d2596396224499fe7cc40467920a216f4da6efb3c281ed451ff7e29bced98ff17476c4779b7760a3e361c4a09285667deb

data/README.md

@@ -6,30 +6,41 @@
 [![Documentation](https://img.shields.io/badge/docs-YARD-blue.svg)](https://cultivatelabs.github.io/raif/)
 
 
-Raif (Ruby AI Framework) is a Rails engine that helps you add AI-powered features to your Rails apps, such as [tasks](#tasks), [conversations](#conversations), and [agents](#agents).  It supports for multiple LLM providers including [OpenAI](#openai), [Anthropic Claude](#anthropic-claude), and [AWS Bedrock](#aws-bedrock).
+Raif (Ruby AI Framework) is a Rails engine that helps you add AI-powered features to your Rails apps, such as [tasks](#tasks), [conversations](#conversations), and [agents](#agents).  It supports for multiple LLM providers including [OpenAI](#openai), [Anthropic Claude](#anthropic-claude), [AWS Bedrock](#aws-bedrock), and [OpenRouter](#openrouter).
 
 Raif is built by [Cultivate Labs](https://www.cultivatelabs.com) and is used to power [ARC](https://www.arcanalysis.ai), an AI-powered research & analysis platform.
 
 ## Table of Contents
 - [Setup](#setup)
   - [OpenAI](#openai)
+    - [OpenAI Completions API](#openai-completions-api)
+    - [OpenAI Responses API](#openai-responses-api)
   - [Anthropic Claude](#anthropic-claude)
   - [AWS Bedrock (Claude)](#aws-bedrock-claude)
+  - [OpenRouter](#openrouter)
 - [Chatting with the LLM](#chatting-with-the-llm)
+  - [Streaming Responses](#streaming-responses)
 - [Key Raif Concepts](#key-raif-concepts)
   - [Tasks](#tasks)
   - [Conversations](#conversations)
+    - [Real-time Streaming Responses](#real-time-streaming-responses)
     - [Conversation Types](#conversation-types)
   - [Agents](#agents)
   - [Model Tools](#model-tools)
+    - [Provider-Managed Tools](#provider-managed-tools)
+- [Images/Files/PDF's](#imagesfilespdfs)
+  - [Images/Files/PDF's in Tasks](#imagesfilespdfs-in-tasks)
+- [Embedding Models](#embedding-models)
 - [Web Admin](#web-admin)
 - [Customization](#customization)
   - [Controllers](#controllers)
   - [Models](#models)
   - [Views](#views)
   - [System Prompts](#system-prompts)
+  - [Adding LLM Models](#adding-llm-models)
 - [Testing](#testing)
 - [Demo App](#demo-app)
+- [Contributing](#contributing)
 - [License](#license)
 
 # Setup
@@ -55,6 +66,8 @@ This will:
 - Copy Raif's database migrations to your application
 - Mount Raif's engine at `/raif` in your application's `config/routes.rb` file
 
+You must configure at least one API key for your LLM provider ([OpenAI](#openai), [Anthropic Claude](#anthropic-claude), [AWS Bedrock](#aws-bedrock-claude), [OpenRouter](#openrouter)). By default, the initializer will load them from environment variables (e.g. `ENV["OPENAI_API_KEY"]`, `ENV["ANTHROPIC_API_KEY"]`, `ENV["OPENROUTER_API_KEY"]`). Alternatively, you can set them directly in `config/initializers/raif.rb`.
+
 Run the migrations. Raif is compatible with both PostgreSQL and MySQL databases.
 ```bash
 rails db:migrate
@@ -77,6 +90,10 @@ end
 Configure your LLM providers. You'll need at least one of:
 
 ## OpenAI
+
+Raif supports both OpenAI's [Completions API](https://platform.openai.com/docs/api-reference/chat) and the newer [Responses API](https://platform.openai.com/docs/api-reference/responses), which provides access to provider-managed tools like web search, code execution, and image generation.
+
+### OpenAI Completions API
 ```ruby
 Raif.configure do |config|
   config.open_ai_models_enabled = true
@@ -85,10 +102,44 @@ Raif.configure do |config|
 end
 ```
 
-Currently supported OpenAI models:
+Currently supported OpenAI Completions API models:
 - `open_ai_gpt_4o_mini`
 - `open_ai_gpt_4o`
 - `open_ai_gpt_3_5_turbo`
+- `open_ai_gpt_4_1`
+- `open_ai_gpt_4_1_mini`
+- `open_ai_gpt_4_1_nano`
+- `open_ai_o1`
+- `open_ai_o1_mini`
+- `open_ai_o3`
+- `open_ai_o3_mini`
+- `open_ai_o4_mini`
+
+### OpenAI Responses API
+```ruby
+Raif.configure do |config|
+  config.open_ai_models_enabled = true
+  config.open_ai_api_key = ENV["OPENAI_API_KEY"]
+  config.default_llm_model_key = "open_ai_responses_gpt_4o"
+end
+```
+
+Currently supported OpenAI Responses API models:
+- `open_ai_responses_gpt_4o_mini`
+- `open_ai_responses_gpt_4o`
+- `open_ai_responses_gpt_3_5_turbo`
+- `open_ai_responses_gpt_4_1`
+- `open_ai_responses_gpt_4_1_mini`
+- `open_ai_responses_gpt_4_1_nano`
+- `open_ai_responses_o1`
+- `open_ai_responses_o1_mini`
+- `open_ai_responses_o1_pro`
+- `open_ai_responses_o3`
+- `open_ai_responses_o3_mini`
+- `open_ai_responses_o3_pro`
+- `open_ai_responses_o4_mini`
+
+The Responses API provides access to [provider-managed tools](#provider-managed-tools), including web search, code execution, and image generation.
 
 ## Anthropic Claude
 ```ruby
@@ -105,10 +156,12 @@ Currently supported Anthropic models:
 - `anthropic_claude_3_5_haiku`
 - `anthropic_claude_3_opus`
 
+The Anthropic adapter provides access to [provider-managed tools](#provider-managed-tools) for web search and code execution.
+
 ## AWS Bedrock (Claude)
 ```ruby
 Raif.configure do |config|
-  config.anthropic_bedrock_models_enabled = true
+  config.bedrock_models_enabled = true
   config.aws_bedrock_region = "us-east-1"
   config.default_llm_model_key = "bedrock_claude_3_5_sonnet"
 end
@@ -119,9 +172,34 @@ Currently supported Bedrock models:
 - `bedrock_claude_3_7_sonnet`
 - `bedrock_claude_3_5_haiku`
 - `bedrock_claude_3_opus`
+- `bedrock_amazon_nova_micro`
+- `bedrock_amazon_nova_lite`
+- `bedrock_amazon_nova_pro`
 
 Note: Raif utilizes the [AWS Bedrock gem](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/BedrockRuntime/Client.html) and AWS credentials should be configured via the AWS SDK (environment variables, IAM role, etc.)
 
+## OpenRouter
+[OpenRouter](https://openrouter.ai/) is a unified API that provides access to multiple AI models from different providers including Anthropic, Meta, Google, and more.
+
+```ruby
+Raif.configure do |config|
+  config.open_router_models_enabled = true
+  config.open_router_api_key = ENV["OPENROUTER_API_KEY"]
+  config.open_router_app_name = "Your App Name" # Optional
+  config.open_router_site_url = "https://yourdomain.com" # Optional
+  config.default_llm_model_key = "open_router_claude_3_7_sonnet"
+end
+```
+
+Currently included OpenRouter models:
+- `open_router_claude_3_7_sonnet`
+- `open_router_llama_3_3_70b_instruct`
+- `open_router_llama_3_1_8b_instruct`
+- `open_router_gemini_2_0_flash`
+- `open_router_deepseek_chat_v3`
+
+See [Adding LLM Models](#adding-llm-models) for more information on adding new OpenRouter models.
+
 # Chatting with the LLM
 
 When using Raif, it's often useful to use one of the [higher level abstractions](#key-raif-concepts) in your application. But when needed, you can utilize `Raif::Llm` to chat with the model directly. All calls to the LLM will create and return a `Raif::ModelCompletion` record, providing you a log of all interactions with the LLM which can be viewed in the [web admin](#web-admin).
@@ -157,10 +235,42 @@ puts model_completion.parsed_response # will strip backticks, parse the JSON, an
 # => {"joke" => "Why don't skeletons fight each other? They don't have the guts."}
 ```
 
+## Streaming Responses
+
+You can enable streaming for any chat call by passing a block to the `chat` method. When streaming is enabled, the block will be called with partial responses as they're received from the LLM:
+
+```ruby
+llm = Raif.llm(:open_ai_gpt_4o)
+model_completion = llm.chat(message: "Tell me a story") do |model_completion, delta, sse_event|
+  # This block is called multiple times as the response streams in.
+  # You could broadcast these updates via Turbo Streams, WebSockets, etc.
+  Turbo::StreamsChannel.broadcast_replace_to(
+    :my_channel,
+    target: "chat-response",
+    partial: "my_partial_displaying_chat_response",
+    locals: { model_completion: model_completion, delta: delta, sse_event: sse_event }
+  )
+end
+
+# The final complete response is available in the model_completion
+puts model_completion.raw_response
+```
+
+You can configure the streaming update frequency by adjusting the chunk size threshold in your Raif configuration:
+
+```ruby
+Raif.configure do |config|
+  # Control how often the model completion is updated & the block is called when streaming.
+  # Lower values = more frequent updates but more database writes.
+  # Higher values = less frequent updates but fewer database writes.
+  config.streaming_update_chunk_size_threshold = 50 # default is 25
+end
+```
+
 # Key Raif Concepts
 
 ## Tasks
-If you have a single-shot task that you want an LLM to do in your application, you should create a `Raif::Task` subclass (see the end of this section for an example of using the task generator), where you'll define the prompt and response format for the task and call via `Raif::Task.run`. For example, say you have a `Document` model in your app and want to have a summarization task for the LLM:
+If you have a single-shot task that you want an LLM to do in your application, you should create a `Raif::Task` subclass, where you'll define the prompt and response format for the task and call via `Raif::Task.run`. For example, say you have a `Document` model in your app and want to have a summarization task for the LLM:
 
 ```bash
 rails generate raif:task DocumentSummarization --response-format html
@@ -171,7 +281,10 @@ This will create a new task in `app/models/raif/tasks/document_summarization.rb`
 ```ruby
 class Raif::Tasks::DocumentSummarization < Raif::ApplicationTask
   llm_response_format :html # options are :html, :text, :json
-  
+  llm_temperature 0.8 # optional, defaults to 0.7
+  llm_response_allowed_tags %w[p b i div strong] # optional, defaults to Rails::HTML5::SafeListSanitizer.allowed_tags
+  llm_response_allowed_attributes %w[style] # optional, defaults to Rails::HTML5::SafeListSanitizer.allowed_attributes
+
   # Any attr_accessor you define can be included as an argument when calling `run`. 
   # E.g. Raif::Tasks::DocumentSummarization.run(document: document, creator: user)
   attr_accessor :document
@@ -229,20 +342,10 @@ module Raif
 
       attr_accessor :topic
 
-      def self.json_response_schema
-        {
-          type: "object",
-          additionalProperties: false,
-          required: ["queries"],
-          properties: {
-            queries: {
-              type: "array",
-              items: {
-                type: "string"
-              }
-            }
-          }
-        }
+      json_response_schema do
+        array :queries do
+          items type: "string"
+        end
       end
 
       def build_prompt
@@ -271,6 +374,8 @@ You are an assistant with expertise in summarizing detailed articles into clear
 You're collaborating with teammate who speaks Spanish. Please respond in Spanish.
 ```
 
+The current list of valid language keys can be found [here](https://github.com/CultivateLabs/raif/blob/main/lib/raif/languages.rb).
+
 ## Conversations
 
 Raif provides `Raif::Conversation` and `Raif::ConversationEntry` models that you can use to  provide an LLM-powered chat interface. It also provides controllers and views for the conversation interface.
@@ -312,6 +417,10 @@ If your app already includes Bootstrap styles, this will render a conversation i
 
 If your app does not include Bootstrap, you can [override the views](#views) to update styles.
 
+### Real-time Streaming Responses
+
+Raif conversations have built-in support for streaming responses, where the LLM's response is displayed progressively as it's being generated. Each time a conversation entry is updated during the streaming response, Raif will call `broadcast_replace_to(conversation)` (where `conversation` is the `Raif::Conversation` associated with the conversation entry). When using the `raif_conversation` view helper, it will automatically set up the subscription for you.
+
 ### Conversation Types
 
 If your application has a specific type of conversation that you use frequently, you can create a custom conversation type by running the generator. For example, say you are implementing a customer support chatbot in your application and want to have a custom conversation type for doing this with the LLM:
@@ -434,39 +543,31 @@ This will create a new model tool in `app/models/raif/model_tools/google_search.
 ```ruby
 class Raif::ModelTools::GoogleSearch < Raif::ModelTool
   # For example tool implementations, see: 
-  # Wikipedia Search Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/wikipedia_search_tool.rb
-  # Fetch URL Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/fetch_url_tool.rb
+  # Wikipedia Search Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/wikipedia_search.rb
+  # Fetch URL Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/fetch_url.rb
+
+  # Define the schema for the arguments that the LLM should use when invoking your tool.
+  # It should be a valid JSON schema. When the model invokes your tool,
+  # the arguments it provides will be validated against this schema using JSON::Validator from the json-schema gem.
+  #
+  # All attributes will be required and additionalProperties will be set to false.
+  #
+  # This schema would expect the model to invoke your tool with an arguments JSON object like:
+  # { "query" : "some query here" }
+  tool_arguments_schema do
+    string :query, description: "The query to search for"
+  end
 
   # An example of how the LLM should invoke your tool. This should return a hash with name and arguments keys.
   # `to_json` will be called on it and provided to the LLM as an example of how to invoke your tool.
-  def self.example_model_invocation
+  example_model_invocation do
     {
       "name": tool_name,
       "arguments": { "query": "example query here" }
     }
   end
 
-  # Define your tool's argument schema here. It should be a valid JSON schema.
-  # When the model invokes your tool, the arguments it provides will be validated
-  # against this schema using JSON::Validator from the json-schema gem.
-  def self.tool_arguments_schema
-    # For example:
-    # {
-    #   type: "object",
-    #   additionalProperties: false,
-    #   required: ["query"],
-    #   properties: {
-    #     query: {
-    #       type: "string",
-    #       description: "The query to search for"
-    #     }
-    #   }
-    # }
-    # Would expect the model to invoke your tool with an arguments JSON object like:
-    # { "query" : "some query here" }
-  end
-
-  def self.tool_description
+  tool_description do
     "Description of your tool that will be provided to the LLM so it knows when to invoke it"
   end
 
@@ -506,6 +607,172 @@ class Raif::ModelTools::GoogleSearch < Raif::ModelTool
 end
 ```
 
+### Provider-Managed Tools
+
+In addition to the ability to create your own model tools, Raif supports provider-managed tools. These are tools that are built into certain LLM providers and run on the provider's infrastructure:
+
+- **`Raif::ModelTools::ProviderManaged::WebSearch`**: Performs real-time web searches and returns relevant results
+- **`Raif::ModelTools::ProviderManaged::CodeExecution`**: Executes code in a secure sandboxed environment (e.g. Python)
+- **`Raif::ModelTools::ProviderManaged::ImageGeneration`**: Generates images based on text descriptions
+
+Current provider-managed tool support:
+| Provider | WebSearch | CodeExecution | ImageGeneration |
+|----------|-----------|---------------|-----------------|
+| OpenAI Responses API | ✅ | ✅ | ✅ |
+| OpenAI Completions API | ❌ | ❌ | ❌ |
+| Anthropic Claude | ✅ | ✅ | ❌ |
+| AWS Bedrock (Claude) | ❌ | ❌ | ❌ |
+| OpenRouter | ❌ | ❌ | ❌ |
+
+To use provider-managed tools, include them in the `available_model_tools` array:
+
+```ruby
+# In a conversation
+conversation = Raif::Conversation.create!(
+  creator: current_user,
+  available_model_tools: [
+    "Raif::ModelTools::ProviderManaged::WebSearch",
+    "Raif::ModelTools::ProviderManaged::CodeExecution"
+  ]
+)
+
+# In an agent
+agent = Raif::Agents::ReActAgent.new(
+  task: "Search for recent news about AI and create a summary chart",
+  available_model_tools: [
+    "Raif::ModelTools::ProviderManaged::WebSearch",
+    "Raif::ModelTools::ProviderManaged::CodeExecution"
+  ],
+  creator: current_user
+)
+
+# Directly in a chat
+llm = Raif.llm(:open_ai_responses_gpt_4_1)
+model_completion = llm.chat(
+  messages: [{ role: "user", content: "What are the latest developments in Ruby on Rails?" }], 
+  available_model_tools: [Raif::ModelTools::ProviderManaged::WebSearch]
+)
+```
+
+## Sending Images/Files/PDF's to the LLM
+
+Raif supports images, files, and PDF's in the messages sent to the LLM.
+
+To include an image, file/PDF in a message, you can use the `Raif::ModelImageInput` and `Raif::ModelFileInput`.
+
+To include an image:
+```ruby
+# From a local file
+image = Raif::ModelImageInput.new(input: "path/to/image.png")
+
+# From a URL
+image = Raif::ModelImageInput.new(url: "https://example.com/image.png")
+
+# From an ActiveStorage attachment (assumes you have a User model with an avatar attachment)
+image = Raif::ModelImageInput.new(input: user.avatar)
+
+# Then chat with the LLM
+llm = Raif.llm(:open_ai_gpt_4o)
+model_completion = llm.chat(messages: [
+  { role: "user", content: ["What's in this image?", image]}
+])
+```
+
+To include a file/PDF:
+```ruby
+# From a local file
+file = Raif::ModelFileInput.new(input: "path/to/file.pdf")
+
+# From a URL
+file = Raif::ModelFileInput.new(url: "https://example.com/file.pdf")
+
+# From an ActiveStorage attachment (assumes you have a Document model with a pdf attachment)
+file = Raif::ModelFileInput.new(input: document.pdf)
+
+# Then chat with the LLM
+llm = Raif.llm(:open_ai_gpt_4o)
+model_completion = llm.chat(messages: [
+  { role: "user", content: ["What's in this file?", file]}
+])
+```
+
+### Images/Files/PDF's in Tasks
+
+You can include images and files/PDF's when running a `Raif::Task`:
+
+To include a file/PDF:
+```ruby
+file = Raif::ModelFileInput.new(input: "path/to/file.pdf")
+
+# Assumes you've created a PdfContentExtraction task
+task = Raif::Tasks::PdfContentExtraction.run(
+  creator: current_user,
+  files: [file]
+)
+```
+
+To include an image:
+```ruby
+image = Raif::ModelImageInput.new(input: "path/to/image.png")
+
+# Assumes you've created a ImageDescriptionGeneration task
+task = Raif::Tasks::ImageDescriptionGeneration.run(
+  creator: current_user,
+  images: [image]
+)
+```
+
+
+# Embedding Models
+
+Raif supports generation of vector embeddings. You can enable and configure embedding models in your Raif configuration:
+
+```ruby
+Raif.configure do |config|
+  config.open_ai_embedding_models_enabled = true
+  config.bedrock_embedding_models_enabled = true
+  
+  config.default_embedding_model_key = "open_ai_text_embedding_3_small"
+end
+```
+
+## Supported Embedding Models
+
+Raif currently supports the following embedding models:
+
+### OpenAI
+- `open_ai_text_embedding_3_small`
+- `open_ai_text_embed ding_3_large`
+- `open_ai_text_embedding_ada_002`
+
+### AWS Bedrock
+- `bedrock_titan_embed_text_v2`
+
+## Creating Embeddings
+
+By default, Raif will used `Raif.config.default_embedding_model_key` to create embeddings. To create an embedding for a piece of text:
+
+```ruby
+# Generate an embedding for a piece of text
+embedding = Raif.generate_embedding!("Your text here")
+
+# Generate an embedding for a piece of text with a specific number of dimensions
+embedding = Raif.generate_embedding!("Your text here", dimensions: 1024)
+
+# If you're using an OpenAI embedding model, you can pass an array of strings to embed multiple texts at once
+embeddings = Raif.generate_embedding!([
+  "Your text here",
+  "Your other text here"
+])
+```
+
+Or to generate embeddings for a piece of text with a specific model:
+
+```ruby
+model = Raif.embedding_model(:open_ai_text_embedding_3_small)
+embedding = model.generate_embedding!("Your text here")
+```
+
 # Web Admin
 
 Raif includes a web admin interface for viewing all interactions with the LLM. Assuming you have the engine mounted at `/raif`, you can access the admin interface at `/raif/admin`.
@@ -516,6 +783,7 @@ The admin interface contains sections for:
 - Conversations
 - Agents
 - Model Tool Invocations
+- Stats
 
 
 ### Model Completions
@@ -537,6 +805,9 @@ The admin interface contains sections for:
   ![Model Tool Invocations Index](./screenshots/admin-model-tool-invocations-index.png)
   ![Model Tool Invocation Detail](./screenshots/admin-model-tool-invocation-show.png)
 
+### Stats
+  ![Stats](./screenshots/admin-stats.png)
+
 # Customization
 
 ## Controllers
@@ -593,6 +864,32 @@ If you don't want to override the system prompt entirely in your task/conversati
 Raif.configure do |config|
   config.conversation_system_prompt_intro = "You are a helpful assistant who specializes in customer support."
   config.task_system_prompt_intro = "You are a helpful assistant who specializes in data analysis."
+  # or with a lambda
+  config.task_system_prompt_intro = ->(task) { "You are a helpful assistant who specializes in #{task.name}." }
+  config.conversation_system_prompt_intro = ->(conversation) { "You are a helpful assistant talking to #{conversation.creator.email}. Today's date is #{Date.today.strftime('%B %d, %Y')}." }
+end
+```
+
+## Adding LLM Models
+
+You can easily add new LLM models to Raif:
+
+```ruby
+# Register the model in Raif's LLM registry
+Raif.register_llm(Raif::Llms::OpenRouter, {
+  key: :open_router_gemini_flash_1_5_8b, # a unique key for the model
+  api_name: "google/gemini-flash-1.5-8b", # name of the model to be used in API calls - needs to match the provider's API name
+  input_token_cost: 0.038 / 1_000_000, # the cost per input token
+  output_token_cost: 0.15 / 1_000_000, # the cost per output token
+})
+
+# Then use the model
+llm = Raif.llm(:open_router_gemini_flash_1_5_8b)
+llm.chat(message: "Hello, world!")
+
+# Or set it as the default LLM model in your initializer
+Raif.configure do |config|
+  config.default_llm_model_key = "open_router_gemini_flash_1_5_8b"
 end
 ```
 
@@ -673,6 +970,12 @@ You can then access the app at [http://localhost:3000](http://localhost:3000).
 
 ![Demo App Screenshot](./screenshots/demo-app.png)
 
+# Contributing
+
+We welcome contributions to Raif! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+**Important**: All PR's should be made against the `dev` branch.
+
 # License
 
 The gem is available as open source under the terms of the MIT License.

data/app/assets/builds/raif.css

@@ -28,6 +28,31 @@
   animation-delay: 0.4s;
 }
 
+.raif-streaming-cursor {
+  display: inline-block;
+  width: 2px;
+  height: 1.1em;
+  margin-bottom: -2px;
+  background-color: currentColor;
+  animation: blink 1s infinite;
+  transform: none;
+  border-radius: 0;
+  position: relative;
+}
+
+.raif-streaming-cursor:before,
+.raif-streaming-cursor:after {
+  display: none;
+}
+
+@keyframes blink {
+  0%, 50% {
+    opacity: 1;
+  }
+  51%, 100% {
+    opacity: 0;
+  }
+}
 @keyframes rotate {
   0% {
     transform: translate(-50%, -50%) rotateZ(0deg);
@@ -71,4 +96,4 @@
   }
 }
 
-/*# sourceMappingURL=data:application/json;base64,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 */
+/*# sourceMappingURL=data:application/json;base64,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 */

data/app/assets/stylesheets/raif/admin/stats.scss

@@ -0,0 +1,12 @@
+.stats-icon {
+  min-width: 46px;
+  text-align: center;
+}
+
+.stats-card {
+  transition: transform 0.2s;
+}
+
+.stats-card:hover {
+  transform: translateY(-5px);
+}

data/app/assets/stylesheets/raif/loader.scss

@@ -28,6 +28,33 @@
   animation-delay: .4s;
 }
 
+// Streaming cursor - a simple blinking cursor
+.raif-streaming-cursor {
+  display: inline-block;
+  width: 2px;
+  height: 1.1em;
+  margin-bottom: -2px;
+  background-color: currentColor;
+  animation: blink 1s infinite;
+  transform: none;
+  border-radius: 0;
+  position: relative;
+}
+
+.raif-streaming-cursor:before,
+.raif-streaming-cursor:after {
+  display: none;
+}
+
+@keyframes blink {
+  0%, 50% {
+    opacity: 1;
+  }
+  51%, 100% {
+    opacity: 0;
+  }
+}
+
 @keyframes rotate {
   0% {
     transform: translate(-50%, -50%) rotateZ(0deg);
@@ -49,7 +76,6 @@
 }
 
 @keyframes spin {
-
   0%,
   100% {
     box-shadow: .3em 0px 0 0px currentcolor;

data/app/controllers/raif/admin/application_controller.rb

@@ -15,6 +15,20 @@ module Raif
         end
       end
 
+      def get_time_range(period)
+        case period
+        when "day"
+          24.hours.ago..Time.current
+        when "week"
+          1.week.ago..Time.current
+        when "month"
+          1.month.ago..Time.current
+        when "all"
+          Time.at(0)..Time.current
+        else
+          24.hours.ago..Time.current
+        end
+      end
     end
   end
 end