ruby_llm-mongoid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: faf4e9de8443c878f505ec2060a9eb6cb399f0137b6af8048c5071cf960d3f28
+  data.tar.gz: 34d9df17d8720aeda41fe9449c2f49d752a562a914898c22433f9683c2bb3e1e
+SHA512:
+  metadata.gz: 5bcee2ff357b9420d83f37f2cb76afa35f03c5fa6efadae125e80011fe5ceebf2fb4e23a563cffd178db00b8f478a6fea9f08cf1f8781f74bcfa08db7d421402
+  data.tar.gz: ffe7ea01a5e0182ff3620861b86ab3d7e861104493762f72820740f58cb65bf8f16b76fd3e08d2c984c062eb71109150b382757b383c372ae8ce105e12849e9c

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,55 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  SuggestExtensions: false
+  NewCops: enable
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+# Metrics are disabled for spec files (standard RuboCop convention).
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+    - "lib/generators/**/*"
+    - "*.gemspec"
+
+# The acts_as_* macros and the chat/model persistence methods are complex by
+# design — they mirror the ruby_llm ActiveRecord integration and must handle
+# many edge cases. Disable length/complexity metrics for these files.
+Metrics/MethodLength:
+  Exclude:
+    - "lib/ruby_llm/mongoid/acts_as.rb"
+    - "lib/ruby_llm/mongoid/chat_methods.rb"
+    - "lib/ruby_llm/mongoid/grid_fs_attachment.rb"
+    - "lib/ruby_llm/mongoid/model_methods.rb"
+    - "lib/ruby_llm/mongoid/message_methods.rb"
+    - "spec/support/openai_stubs.rb"
+
+Metrics/AbcSize:
+  Exclude:
+    - "lib/ruby_llm/mongoid/acts_as.rb"
+    - "lib/ruby_llm/mongoid/chat_methods.rb"
+    - "lib/ruby_llm/mongoid/grid_fs_attachment.rb"
+    - "lib/ruby_llm/mongoid/model_methods.rb"
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - "lib/ruby_llm/mongoid/chat_methods.rb"
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - "lib/ruby_llm/mongoid/chat_methods.rb"
+
+Metrics/ModuleLength:
+  Exclude:
+    - "lib/ruby_llm/mongoid/chat_methods.rb"
+
+Metrics/ClassLength:
+  Exclude:
+    - "lib/ruby_llm/mongoid/acts_as.rb"

data/.ruby-version

@@ -0,0 +1 @@
+3.3.6

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-06-17
+
+### Added
+
+- `acts_as_chat` macro — persists chat sessions to MongoDB with full parity to ruby_llm's ActiveRecord integration
+- `acts_as_message` macro — persists messages with role, content, token counts, thinking fields, and tool-call associations
+- `acts_as_tool_call` macro — persists provider-issued tool calls and links result messages via `parent_tool_call_id`
+- `acts_as_model` macro — persists LLM model registry records; supports `refresh!` and `save_to_database`
+- `RubyLLM::Mongoid::MongoidSource` — plugs into `RubyLLM.config.model_registry_source` for Mongoid-backed model registry
+- `RubyLLM::Mongoid::Transaction` — wraps blocks in multi-document transactions with automatic fallback for standalone mongod
+- `bin/rails g ruby_llm:mongoid:install` generator — creates model files with field declarations (no migrations needed)
+- SimpleCov with ≥ 90% line and ≥ 50% branch coverage enforced on every CI run
+- `RubyLLM::Mongoid::GridFsAttachment` concern — opt-in GridFS-backed file attachments with automatic cleanup on message/chat destroy
+- Full RSpec suite against a real MongoDB 8.0 instance; spec_helper auto-starts a Docker container if none is reachable
+- GitHub Actions `ci.yml` — tests on Ruby 3.2–3.4 with MongoDB 8.0, separate RuboCop lint job, coverage artifact upload
+- GitHub Actions `release.yml` — automated gem publishing on `v*.*.*` tags

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 washu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,253 @@
+# ruby_llm-mongoid
+
+[![CI](https://github.com/washu/ruby_llm-mongoid/actions/workflows/ci.yml/badge.svg)](https://github.com/washu/ruby_llm-mongoid/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/washu/ruby_llm-mongoid/badge.svg?branch=main)](https://coveralls.io/github/washu/ruby_llm-mongoid?branch=main)
+[![Gem Version](https://img.shields.io/gem/v/ruby_llm-mongoid)](https://rubygems.org/gems/ruby_llm-mongoid)
+
+Drop-in Mongoid persistence for [ruby_llm](https://github.com/crmne/ruby_llm). Use MongoDB as your Rails model layer instead of ActiveRecord — same `acts_as_chat` API, same feel.
+
+## Requirements
+
+- Ruby >= 3.3
+- Mongoid >= 8.0
+- ruby_llm >= 1.16
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "ruby_llm-mongoid"
+```
+
+## Quick start
+
+### 1. Generate models
+
+```bash
+bin/rails g ruby_llm:mongoid:install
+```
+
+This creates four model files (`Chat`, `Message`, `ToolCall`, `LlmModel`) and `config/initializers/ruby_llm.rb`. No migrations — Mongoid is schemaless; fields are declared in the model files.
+
+### 2. Create indexes
+
+```bash
+bin/rails db:mongoid:create_indexes
+```
+
+### 3. Configure API keys
+
+Edit `config/initializers/ruby_llm.rb`:
+
+```ruby
+RubyLLM.configure do |config|
+  config.openai_api_key    = ENV["OPENAI_API_KEY"]
+  config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+end
+```
+
+### 4. Seed the model registry
+
+```bash
+bin/rails runner "LlmModel.save_to_database"
+```
+
+This populates MongoDB with the bundled model list so `Chat.create!(model: "gpt-4o-mini")` can resolve the model record.
+
+### 5. Start chatting
+
+```ruby
+chat = Chat.create!(model: "gpt-4o-mini")
+chat.ask("What is the capital of France?")
+# => saves user + assistant messages to MongoDB
+```
+
+## Model setup
+
+### Default (generated) layout
+
+```ruby
+class Chat
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  acts_as_chat model: :llm_model, model_class: "LlmModel"
+end
+
+class Message
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :role,                  type: String
+  field :content,               type: String
+  field :input_tokens,          type: Integer
+  field :output_tokens,         type: Integer
+  # ...additional token/thinking fields
+
+  acts_as_message model: :llm_model, model_class: "LlmModel"
+end
+
+class ToolCall
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :tool_call_id,  type: String
+  field :name,          type: String
+  field :arguments,     type: Hash, default: {}
+
+  acts_as_tool_call
+end
+
+class LlmModel
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :model_id,  type: String
+  field :name,      type: String
+  field :provider,  type: String
+  # ...pricing/capability fields
+
+  acts_as_model
+end
+```
+
+### Custom class / association names
+
+```ruby
+class Conversation
+  include Mongoid::Document
+
+  acts_as_chat messages: :turns,
+               message_class: "Turn",
+               model: :ai_model,
+               model_class: "AiModel"
+end
+```
+
+## API reference
+
+### Chat
+
+```ruby
+chat = Chat.create!(model: "gpt-4o-mini")
+chat = Chat.create!(model: "claude-opus-4-7", provider: "anthropic")
+
+chat.ask("Hello!")
+chat.say("Hello!")    # alias for ask
+
+chat.with_instructions("You are a helpful assistant.")
+chat.with_instructions("More context.", append: true)
+chat.with_runtime_instructions("Only reply in French.")  # not persisted to DB
+
+chat.with_model("claude-opus-4-7")
+chat.with_tool(MyTool)
+chat.with_tools(ToolA, ToolB)
+chat.with_temperature(0.7)
+chat.with_thinking(budget: 5000)
+
+chat.on_new_message  { |msg| puts msg.content }
+chat.on_end_message  { |msg| broadcast(msg) }
+
+chat.cost  # => RubyLLM::Cost
+```
+
+### Message
+
+```ruby
+msg = chat.messages_association.last
+msg.to_llm          # => RubyLLM::Message
+msg.tokens          # => RubyLLM::Tokens
+msg.cost            # => RubyLLM::Cost
+msg.to_partial_path # => "messages/assistant"
+```
+
+### Model registry
+
+`acts_as_model` automatically registers a `MongoidSource` with `RubyLLM.config.model_registry_source`, so `RubyLLM.models` reads from MongoDB on boot instead of the bundled JSON file.
+
+```ruby
+LlmModel.save_to_database  # seed MongoDB from the bundled model registry (run once after install)
+LlmModel.refresh!          # fetch the latest list from all providers, then persist to MongoDB
+```
+
+Both methods are idempotent — `refresh!` is a good candidate for a periodic background job or a deploy hook.
+
+## Differences from ActiveRecord integration
+
+| Concern | ActiveRecord | Mongoid (this gem) |
+|---|---|---|
+| Primary key type | integer | BSON::ObjectId |
+| Tool-call result FK field | `tool_call_id` (integer) | `parent_tool_call_id` (ObjectId) |
+| Transactions | native | requires replica set; auto no-op on standalone |
+| File attachments | ActiveStorage | GridFS via `GridFsAttachment` concern |
+| `has_many :through` | supported | replaced by direct queries |
+
+### `parent_tool_call_id` field name
+
+In the ActiveRecord integration the FK column linking a tool-result message back to its ToolCall is named `tool_call_id` (integer). Mongoid uses `parent_tool_call_id` (BSON::ObjectId) to avoid a type collision with the string `tool_call_id` field that stores the provider-issued call ID. This is handled automatically — you don't need to think about it unless you are writing raw queries.
+
+## Transactions
+
+Multi-document transactions require a MongoDB **replica set** or Atlas cluster. On a standalone `mongod` the transaction helper automatically falls back to running the block without a transaction — useful for development and testing.
+
+For production, run at minimum a single-node replica set:
+
+```bash
+# mongod.conf: add replication.replSetName: "rs0"
+mongosh --eval "rs.initiate()"
+```
+
+## File attachments (GridFS)
+
+Include `RubyLLM::Mongoid::GridFsAttachment` in your message model to store attachments in MongoDB's native GridFS bucket instead of ActiveStorage:
+
+```ruby
+class Message
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include RubyLLM::Mongoid::GridFsAttachment
+
+  field :role,    type: String
+  field :content, type: String
+  # ...other fields
+
+  acts_as_message model: :llm_model, model_class: "LlmModel"
+end
+```
+
+Then pass files to `ask` the same way you would with the ActiveRecord integration:
+
+```ruby
+chat.ask("What's in this image?", with: [params[:file]])
+chat.ask("Summarise this PDF.",    with: ["/path/to/doc.pdf"])
+```
+
+Files are stored in a GridFS bucket named `"attachments"` by default. Change it per model:
+
+```ruby
+class Message
+  include RubyLLM::Mongoid::GridFsAttachment
+  use_gridfs_bucket :llm_files
+end
+```
+
+GridFS files are automatically deleted when the owning message or its parent chat is destroyed.
+
+## Testing
+
+```bash
+bundle exec rspec
+```
+
+The spec_helper checks whether MongoDB is reachable on `localhost:27017`. If nothing is listening it starts a `mongo:8.0` Docker container automatically and stops it when the suite exits. You don't need to start MongoDB manually.
+
+The suite uses `database_cleaner-mongoid` for collection-level isolation between examples. LLM HTTP calls are stubbed with WebMock — no real API keys required.
+
+## Contributing
+
+Bug reports and pull requests welcome at [github.com/SalScotto/ruby_llm-mongoid](https://github.com/SalScotto/ruby_llm-mongoid).
+
+## License
+
+MIT — see [LICENSE.txt](LICENSE.txt).

data/Rakefile

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

data/build_release.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+set -euo pipefail
+
+# Maintainer release helper.
+#
+# Usage:
+#   SKIP_PUSH=1 ./build_release.sh       # build and verify only
+#   ./build_release.sh                   # build, then let `gem push` prompt for MFA
+#   GEM_HOST_OTP=123456 ./build_release.sh  # build and publish with explicit OTP
+
+ROOT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$ROOT_DIR"
+
+VERSION="$(ruby -r ./lib/ruby_llm/mongoid/version.rb -e 'puts RubyLLM::Mongoid::VERSION')"
+GEM_FILE="ruby_llm-mongoid-${VERSION}.gem"
+
+echo "Building gem version ${VERSION}..."
+rm -f "$GEM_FILE"
+gem build ruby_llm-mongoid.gemspec
+
+if [[ ! -f "$GEM_FILE" ]]; then
+  echo "Expected gem file not found: $GEM_FILE" >&2
+  exit 1
+fi
+
+if [[ "${SKIP_PUSH:-0}" == "1" ]]; then
+  echo "SKIP_PUSH=1 set; build verified, skipping publish."
+  exit 0
+fi
+
+echo "Pushing $GEM_FILE to RubyGems..."
+if [[ -n "${GEM_HOST_OTP:-}" ]]; then
+  gem push "$GEM_FILE" --otp "$GEM_HOST_OTP"
+else
+  gem push "$GEM_FILE"
+fi
+
+echo "Done!"

data/lib/generators/ruby_llm/mongoid/install/install_generator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLLM
+  module Generators
+    module Mongoid
+      # Generator that scaffolds Mongoid model files for ruby_llm-mongoid.
+      # Unlike the ActiveRecord generator there are no migrations — Mongoid models
+      # declare their fields inline.
+      #
+      # Usage:
+      #   bin/rails g ruby_llm:mongoid:install [chat:ChatName] [message:MessageName] ...
+      class InstallGenerator < Rails::Generators::Base
+        namespace "ruby_llm:mongoid:install"
+
+        source_root File.expand_path("templates", __dir__)
+
+        argument :model_mappings, type: :array, default: [],
+                                  banner: "chat:ChatName message:MessageName ..."
+
+        desc "Creates Mongoid model files for the ruby_llm-mongoid integration."
+
+        def create_model_files
+          template "chat_model.rb.tt",      "app/models/#{chat_model_name.underscore}.rb"
+          template "message_model.rb.tt",   "app/models/#{message_model_name.underscore}.rb"
+          template "tool_call_model.rb.tt", "app/models/#{tool_call_model_name.underscore}.rb"
+          template "model_model.rb.tt",     "app/models/#{model_model_name.underscore}.rb"
+        end
+
+        def create_initializer
+          template "initializer.rb.tt", "config/initializers/ruby_llm.rb"
+        end
+
+        def create_convention_directories
+          %w[agents tools schemas prompts].each do |name|
+            empty_directory "app/#{name}"
+          end
+        end
+
+        def show_install_info
+          say "\n  ruby_llm-mongoid installed!", :green
+          say "\n  Next steps:", :yellow
+          say "     1. Ensure mongoid.yml is configured (bin/rails g mongoid:config)"
+          say "     2. Run: bin/rails ruby_llm:mongoid:create_indexes"
+          say "     3. Set your API keys in config/initializers/ruby_llm.rb"
+          say "     4. Start chatting: #{chat_model_name}.create!(model: 'gpt-4.1-nano').ask('Hello!')"
+          say "\n  Documentation: https://github.com/SalScotto/ruby_llm-mongoid\n", :cyan
+        end
+
+        private
+
+        def mappings
+          @mappings ||= parse_mappings
+        end
+
+        def parse_mappings
+          result = { "chat" => "Chat", "message" => "Message",
+                     "tool_call" => "ToolCall", "model" => "LlmModel" }
+          model_mappings.each do |pair|
+            key, value = pair.split(":")
+            result[key] = value if key && value
+          end
+          result
+        end
+
+        def chat_model_name
+          mappings.fetch("chat", "Chat")
+        end
+
+        def message_model_name
+          mappings.fetch("message", "Message")
+        end
+
+        def tool_call_model_name
+          mappings.fetch("tool_call", "ToolCall")
+        end
+
+        def model_model_name
+          mappings.fetch("model", "LlmModel")
+        end
+      end
+    end
+  end
+end

data/lib/generators/ruby_llm/mongoid/install/templates/chat_model.rb.tt

@@ -0,0 +1,6 @@
+class <%= chat_model_name %>
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  acts_as_chat
+end

data/lib/generators/ruby_llm/mongoid/install/templates/initializer.rb.tt

@@ -0,0 +1,6 @@
+RubyLLM.configure do |config|
+  config.openai_api_key    = ENV.fetch("OPENAI_API_KEY", nil)
+  config.anthropic_api_key = ENV.fetch("ANTHROPIC_API_KEY", nil)
+  # config.default_model   = "gpt-4.1-nano"
+  # config.model_registry_class = "<%= model_model_name %>"
+end

data/lib/generators/ruby_llm/mongoid/install/templates/message_model.rb.tt

@@ -0,0 +1,21 @@
+class <%= message_model_name %>
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :role,                type: String
+  field :content,             type: String
+  field :content_raw,         type: Hash
+  field :thinking_text,       type: String
+  field :thinking_signature,  type: String
+  field :thinking_tokens,     type: Integer
+  field :input_tokens,        type: Integer
+  field :output_tokens,       type: Integer
+  field :cached_tokens,       type: Integer
+  field :cache_creation_tokens, type: Integer
+
+  index({ role: 1 })
+  index({ created_at: 1 })
+  index({ parent_tool_call_id: 1 }, sparse: true)
+
+  acts_as_message
+end