axn-ruby_llm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c8aae7528ce13d8b34d96781ea472dec9059aaadd029176c8442da9a828c88c
+  data.tar.gz: 5d45458a6c80b9679fa3a59c12e9674264891788bbd586b26fb589763403bd19
+SHA512:
+  metadata.gz: e42eb1a60816cf49c579ebe9343ffa53ff39eadb95a746cd624a4bc78a1209ef8f52f8c2f566566d8d47fc45b16da86161bb88e179814b77bd919c5af44b45af
+  data.tar.gz: 12ca3f1d02a06c8c0e0d1120a9d4b600b37dde32fed917020cd50ff129958e9509cf4b87bb0037f79e50e227669bccec4ccf3bfb09bfb80ae371842ac66fd70a

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [0.1.0] - 2026-05-21
+
+Initial release.
+
+- `Axn::RubyLLM::Ask` action — port of the `Actions::LLM::Ask` pattern from buyout-app, with parameterized model/system_prompt/temperature and opt-in JSON mode (default `false`).
+- `Axn::RubyLLM.ask` / `ask!` module-level shortcuts.
+- Structured output: pass `schema:` (a `RubyLLM::Schema` class, instance, or any JSON Schema hash) to enable provider-enforced structured output via `RubyLLM::Chat#with_schema`. Result returns a parsed Hash; non-JSON responses fail with `"Schema response was not valid JSON"`. Takes precedence over `json: true`.
+- Result exposes `response`, `raw_message`, `input_tokens`, `output_tokens`, `cost` (Float USD total), and `cost_breakdown` (`RubyLLM::Cost` struct). Cost fields are nil when RubyLLM lacks pricing for the model.
+- OpenTelemetry span enrichment: when an OTel SDK is loaded, every `Ask` call sets `gen_ai.request.model`, `gen_ai.response.model`, `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, `gen_ai.usage.cost` (USD), and `axn.ruby_llm.stubbed` on the existing `axn.call` span. No configuration required; no-op if OTel is not loaded. Full LLM-level tracing (individual chat calls, tool calls, embeddings) requires [`opentelemetry-instrumentation-ruby_llm`](https://github.com/thoughtbot/opentelemetry-instrumentation-ruby_llm) in your own Gemfile.
+- Production gating: `Axn::RubyLLM.configure { |c| c.enabled = -> { ... } }` (Boolean or callable). When disabled, `Ask` returns a success result with stub content (`response: "stubbed response value"` for plain, `{ "stubbed" => true }` for json/schema; `raw_message` is an `Ask::StubMessage` Data instance; tokens/cost zeroed) and `result.stubbed == true`.
+- Rate-limit handling rescues `RubyLLM::RateLimitError` (HTTP 429, provider-agnostic) and fails with `"Rate limit reached: <message>"`.
+- `Axn::RubyLLM::RSpec::Helpers` — `stub_axn_ruby_llm` helper accepting `response:`, optional `model:`, `schema:`, `input_tokens:`, `output_tokens:`, `cost:`.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Teamshares, Inc.
+
+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,169 @@
+# axn-ruby_llm
+
+Call LLMs from [Axn](https://github.com/teamshares/axn) actions using [RubyLLM](https://github.com/crmne/ruby_llm), with declarative error handling, optional JSON mode, configurable defaults, and cost/token tracking.
+
+Part of the `axn-*` extension ecosystem — see also [axn-mcp](https://github.com/teamshares/axn-mcp).
+
+### Why use this over calling RubyLLM directly?
+
+Three things you'd otherwise build at every callsite:
+
+1. **Structured error handling.** The Axn error DSL declaratively maps `RateLimitError`, `JSON::ParserError`, and generic `StandardError` to clean failure messages. Callers check `result.ok?` instead of wrapping every call in `begin/rescue`.
+
+2. **Production gating.** A single `c.enabled = -> { Rails.env.production? }` in an initializer stubs every LLM call in non-prod environments — no per-callsite guards needed. The stub is typed (`stubbed: true`, `input_tokens: 0`, etc.) so downstream code doesn't need to branch on it either.
+
+3. **Cost/token tracking, exposed automatically.** Every call exposes `input_tokens`, `output_tokens`, `cost`, and `cost_breakdown` without you doing the `RubyLLM.models.find` lookup manually. If your app uses OpenTelemetry, these values are also set as attributes on the existing `axn.call` span — no configuration required.
+
+> **Scope note:** This gem covers the subset of RubyLLM functionality that [Teamshares](https://github.com/teamshares) uses internally — single-turn chat, structured output, and basic observability. It is intentionally minimal rather than a full-featured wrapper. Feedback and pull requests to extend it are very welcome.
+
+---
+
+## Installation
+
+```ruby
+gem "axn-ruby_llm"
+```
+
+Configure RubyLLM as normal (e.g. in `config/initializers/ruby_llm.rb`). The default model is `gpt-4o-mini`, but any [RubyLLM-supported provider](https://rubyllm.com/llms) works — just configure the appropriate API key and pass `model:` to override:
+
+```ruby
+RubyLLM.configure do |c|
+  c.openai_api_key  = ENV["OPENAI_API_KEY"]   # OpenAI
+  c.anthropic_api_key = ENV["ANTHROPIC_API_KEY"] # or Anthropic, Gemini, etc.
+end
+```
+
+Optionally configure gem-level defaults:
+
+```ruby
+Axn::RubyLLM.configure do |c|
+  c.default_model = "gpt-4o-mini" # default; override with any RubyLLM model ID
+end
+```
+
+## Usage
+
+```ruby
+result = Axn::RubyLLM.ask(
+  prompt: "Summarize this Slack thread: #{thread_text}"
+)
+result.response  # => "The team decided to..."
+
+# JSON mode
+result = Axn::RubyLLM.ask(
+  prompt: build_extraction_prompt(doc),
+  json: true
+)
+result.response  # => { "company" => "Acme", "founded" => 1999 }
+
+# With system prompt and model override
+result = Axn::RubyLLM.ask(
+  prompt: user_message,
+  system_prompt: "You are a concise financial analyst.",
+  model: "gpt-4o",
+  temperature: 0.2
+)
+```
+
+The underlying action class is available as `Axn::RubyLLM::Ask` for cases where you need the full `Axn` interface (`call!`, `call_async`, instrumentation hooks, etc.).
+
+### Structured output via schema
+
+Pass `schema:` to enable provider-enforced structured output (e.g. OpenAI strict mode) via `RubyLLM::Chat#with_schema`. The result's `response` is the parsed Hash.
+
+```ruby
+class CompanyMatch < RubyLLM::Schema
+  integer :company_id, description: "ID of the matched company, or null"
+  number :confidence, description: "0.0–1.0"
+  string :reasoning
+end
+
+result = Axn::RubyLLM.ask(
+  prompt: "Which company is this thread about?\n\n#{thread_text}",
+  schema: CompanyMatch,
+)
+result.response # => { "company_id" => 42, "confidence" => 0.92, "reasoning" => "..." }
+```
+
+`schema:` accepts a [`ruby_llm-schema`](https://github.com/crmne/ruby_llm-schema) class or instance — anything `RubyLLM::Chat#with_schema` accepts, including a raw JSON Schema hash. The `ruby_llm-schema` gem is recommended but not required; declare it in your own Gemfile if you want the DSL. When `schema:` is set, `json: true` is ignored.
+
+### Token counts and cost
+
+Every successful result exposes token usage and cost in two tiers:
+
+```ruby
+result = Axn::RubyLLM.ask(prompt: "...")
+
+# Flat (common case)
+result.input_tokens    # => 412
+result.output_tokens   # => 78
+result.cost            # => 0.00056 (Float USD total; nil if RubyLLM has no pricing for the model)
+
+# Resolved breakdown — RubyLLM::Cost struct
+result.cost_breakdown  # => #<Cost input: 0.0004, output: 0.00016, cache_read: 0.0, ..., total: 0.00056>
+
+# Full escape hatch — the raw RubyLLM::Message for cache/thinking tokens, etc.
+result.raw_message     # => #<RubyLLM::Message ...>
+```
+
+`cost` and `cost_breakdown` are both `nil` when RubyLLM lacks pricing for the model (e.g. unknown/custom endpoints). Token counts are nil only if the provider did not return them.
+
+Errors are handled via Axn's declarative `error` DSL:
+- `JSON::ParserError` → result fails with `"Failed to parse JSON from LLM response"`
+- `RubyLLM::RateLimitError` (HTTP 429, provider-agnostic) → result fails with `"Rate limit reached: <message>"`
+- `schema:` set but LLM returned non-JSON → result fails with `"Schema response was not valid JSON"`
+- Any other `StandardError` → result fails with `"LLM request failed: <message>"`
+
+## Testing
+
+In your specs, require the helpers and use `stub_axn_ruby_llm`:
+
+```ruby
+require "axn/ruby_llm/rspec"
+
+it "summarizes the thread" do
+  stub_axn_ruby_llm(response: "The team agreed to ship on Friday.")
+  result = Axn::RubyLLM.ask(prompt: "...")
+  expect(result.response).to include("ship on Friday")
+end
+```
+
+## OpenTelemetry
+
+If your app uses OpenTelemetry, `axn` already wraps every action in an `axn.call` span. This gem enriches that span with LLM-specific attributes automatically — no configuration required:
+
+| Attribute | Value |
+|---|---|
+| `gen_ai.request.model` | The model requested |
+| `gen_ai.response.model` | The model that responded |
+| `gen_ai.usage.input_tokens` | Prompt token count |
+| `gen_ai.usage.output_tokens` | Completion token count |
+| `gen_ai.usage.cost` | USD total (non-standard; useful for spend filtering) |
+| `axn.ruby_llm.stubbed` | `true` when production gating returned a stub |
+
+For LLM-level tracing (individual `RubyLLM.chat` calls, tool calls, embeddings, prompt content), add [`opentelemetry-instrumentation-ruby_llm`](https://github.com/thoughtbot/opentelemetry-instrumentation-ruby_llm) to your own Gemfile and configure it per its README. It is not a dependency of this gem.
+
+## Production gating
+
+Set `Configuration#enabled` to gate LLM calls — useful for skipping spend in non-production environments. Accepts a Boolean or a callable (evaluated per call):
+
+```ruby
+Axn::RubyLLM.configure do |c|
+  c.enabled = -> { Rails.env.production? }
+  # c.enabled = false  # always stub
+  # c.enabled = true   # default; always run
+end
+```
+
+When disabled, `Ask` returns a **success** result with obvious stub content, so callers don't need per-callsite branching:
+
+| Field | Stubbed value |
+|---|---|
+| `response` | `"stubbed response value"` (plain) / `{ "stubbed" => true }` (`json: true` or `schema:`) |
+| `raw_message` | `Ask::StubMessage` Data instance with `.content`, `.input_tokens`, `.output_tokens`, `.model_id` |
+| `input_tokens` / `output_tokens` | `0` |
+| `cost` | `0.0` |
+| `cost_breakdown` | `nil` |
+| `stubbed` | `true` |
+
+Check `result.stubbed` if you need to branch on it (e.g. skip downstream writes that would otherwise persist stub LLM output). The Axn result's `message` is `"disabled - returning stubbed values"` for the same purpose.

data/Rakefile

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

data/lib/axn/ruby_llm/ask.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Axn
+  module RubyLLM
+    class Ask
+      include Axn
+
+      expects :prompt
+      expects :json, type: :boolean, default: false
+      expects :schema, optional: true
+      expects :model, optional: true
+      expects :system_prompt, optional: true
+      expects :temperature, optional: true
+
+      exposes :response
+      exposes :raw_message
+      exposes :input_tokens, allow_nil: true
+      exposes :output_tokens, allow_nil: true
+      exposes :cost, allow_nil: true
+      exposes :cost_breakdown, allow_nil: true
+      exposes :stubbed, type: :boolean, default: false
+
+      StubMessage = Data.define(:content, :input_tokens, :output_tokens, :model_id)
+
+      error prefix: "LLM request failed: "
+      error "Failed to parse JSON from LLM response", if: JSON::ParserError
+
+      before do
+        if disabled?
+          exposures = stubbed_exposures
+          record_otel_attributes!(
+            input_tokens: exposures[:input_tokens],
+            output_tokens: exposures[:output_tokens],
+            cost: exposures[:cost],
+            response_model: nil,
+            stubbed: true,
+          )
+          done!("disabled - returning stubbed values", **exposures)
+        end
+      end
+
+      def call
+        expose(
+          response: parsed_response,
+          raw_message: llm_response,
+          input_tokens: llm_response.input_tokens,
+          output_tokens: llm_response.output_tokens,
+          cost_breakdown:,
+          cost: cost_breakdown&.total,
+          stubbed: false,
+        )
+        record_otel_attributes!(
+          input_tokens: llm_response.input_tokens,
+          output_tokens: llm_response.output_tokens,
+          cost: cost_breakdown&.total,
+          response_model: llm_response.model_id,
+          stubbed: false,
+        )
+      rescue ::RubyLLM::RateLimitError => e
+        fail! "Rate limit reached: #{e.message}"
+      end
+
+      private
+
+      def disabled? = !Axn::RubyLLM.configuration.enabled?
+
+      def stubbed_exposures
+        content = schema || json ? { "stubbed" => true } : "stubbed response value"
+        {
+          response: content,
+          raw_message: StubMessage.new(content:, input_tokens: 0, output_tokens: 0, model_id: "stubbed"),
+          input_tokens: 0,
+          output_tokens: 0,
+          cost: 0.0,
+          cost_breakdown: nil,
+          stubbed: true,
+        }
+      end
+
+      def parsed_response
+        if schema
+          # with_schema makes RubyLLM parse the response into a Hash on success
+          return llm_response.content if llm_response.content.is_a?(Hash)
+
+          fail! "Schema response was not valid JSON"
+        end
+        json ? JSON.parse(llm_response.content) : llm_response.content
+      end
+
+      def cost_breakdown
+        return nil unless model_info
+
+        llm_response.cost(model: model_info)
+      end
+
+      memo def model_info
+        ::RubyLLM.models.find(llm_response.model_id)
+      rescue ::RubyLLM::ModelNotFoundError
+        nil
+      end
+
+      memo def llm_response = chat.ask(prompt)
+
+      memo def chat
+        ::RubyLLM.chat(model: resolved_model).tap do |c|
+          c.with_instructions(system_prompt) if system_prompt
+          c.with_schema(schema) if schema
+          c.with_params(response_format: { type: "json_object" }) if json && !schema
+          c.with_params(temperature:) if temperature
+        end
+      end
+
+      def resolved_model
+        model || Axn::RubyLLM.configuration.default_model
+      end
+
+      def record_otel_attributes!(input_tokens:, output_tokens:, cost:, response_model:, stubbed:)
+        return unless defined?(::OpenTelemetry::Trace)
+
+        span = ::OpenTelemetry::Trace.current_span
+        return unless span&.context&.valid?
+
+        span.set_attribute("gen_ai.request.model", resolved_model) if resolved_model
+        span.set_attribute("gen_ai.response.model", response_model) if response_model
+        span.set_attribute("gen_ai.usage.input_tokens", input_tokens) if input_tokens
+        span.set_attribute("gen_ai.usage.output_tokens", output_tokens) if output_tokens
+        span.set_attribute("gen_ai.usage.cost", cost) if cost
+        span.set_attribute("axn.ruby_llm.stubbed", stubbed) unless stubbed.nil?
+      rescue StandardError
+        # never let telemetry break the action
+      end
+    end
+  end
+end

data/lib/axn/ruby_llm/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Axn
+  module RubyLLM
+    class Configuration
+      DEFAULT_MODEL = "gpt-4o-mini"
+
+      attr_accessor :default_model, :enabled
+
+      def initialize
+        @default_model = DEFAULT_MODEL
+        @enabled = true
+      end
+
+      def enabled?
+        enabled.respond_to?(:call) ? !!enabled.call : !!enabled
+      end
+    end
+  end
+end

data/lib/axn/ruby_llm/rspec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "axn-ruby_llm"
+
+module Axn
+  module RubyLLM
+    module RSpec
+      module Helpers
+        # Stubs RubyLLM so that Ask returns a canned response.
+        #
+        # Usage in a spec:
+        #   stub_axn_ruby_llm(response: "Here is a summary.")
+        #   stub_axn_ruby_llm(response: { "key" => "value" })  # auto-JSON-serialized for json: true calls
+        #   stub_axn_ruby_llm(response: { "k" => "v" }, schema: MySchema) # Hash passed through unparsed
+        #   stub_axn_ruby_llm(response: "...", input_tokens: 100, output_tokens: 50, cost: 0.0023)
+        #
+        # Returns the chat instance double for further assertions if needed.
+        def stub_axn_ruby_llm(response:, model: nil, schema: nil, input_tokens: nil, output_tokens: nil, cost: nil)
+          resolved_model_id = model || Axn::RubyLLM.configuration.default_model
+          llm_message = _stub_axn_ruby_llm_message(response, resolved_model_id, input_tokens, output_tokens, schema:)
+          chat_instance = _stub_axn_ruby_llm_chat(model, llm_message, schema:)
+          _stub_axn_ruby_llm_cost(llm_message, resolved_model_id, cost)
+          chat_instance
+        end
+
+        private
+
+        def _stub_axn_ruby_llm_message(response, model_id, input_tokens, output_tokens, schema:)
+          content = if schema
+                      response
+                    elsif response.is_a?(Hash)
+                      response.to_json
+                    else
+                      response.to_s
+                    end
+          instance_double(::RubyLLM::Message, content:, input_tokens:, output_tokens:, model_id:)
+        end
+
+        def _stub_axn_ruby_llm_chat(model, llm_message, schema:)
+          chat_instance = instance_double(::RubyLLM::Chat)
+          if model
+            allow(::RubyLLM).to receive(:chat).with(model:).and_return(chat_instance)
+          else
+            allow(::RubyLLM).to receive(:chat).and_return(chat_instance)
+          end
+          allow(chat_instance).to receive(:with_instructions).and_return(chat_instance)
+          allow(chat_instance).to receive(:with_params).and_return(chat_instance)
+          # Always stub with_schema so specs don't blow up if production code passes schema:
+          # even when the helper is called without schema:. Use a tight matcher when schema
+          # is known so the stub still validates the correct class is passed.
+          if schema
+            allow(chat_instance).to receive(:with_schema).with(schema).and_return(chat_instance)
+          else
+            allow(chat_instance).to receive(:with_schema).and_return(chat_instance)
+          end
+          allow(chat_instance).to receive(:ask).and_return(llm_message)
+          chat_instance
+        end
+
+        def _stub_axn_ruby_llm_cost(llm_message, model_id, cost)
+          model_info = instance_double("RubyLLM::Model")
+          allow(::RubyLLM.models).to receive(:find).with(model_id).and_return(model_info)
+          # Default to zero cost so specs exercise the "model found, cost computed" path.
+          # Pass cost: explicitly to assert a specific value.
+          cost_total = cost || 0.0
+          cost_struct = instance_double(::RubyLLM::Cost, total: cost_total)
+          allow(llm_message).to receive(:cost).with(model: model_info).and_return(cost_struct)
+        end
+      end
+    end
+  end
+end
+
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.include Axn::RubyLLM::RSpec::Helpers
+  end
+end

data/lib/axn/ruby_llm/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Axn
+  module RubyLLM
+    VERSION = "0.1.0"
+  end
+end

data/lib/axn/ruby_llm.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "axn"
+
+require_relative "ruby_llm/version"
+require_relative "ruby_llm/configuration"
+require_relative "ruby_llm/ask"
+
+module Axn
+  module RubyLLM
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def reset_configuration!
+        @configuration = nil
+      end
+
+      def ask(**) = Ask.call(**)
+      def ask!(**) = Ask.call!(**)
+    end
+  end
+end

data/lib/axn-ruby_llm.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "axn/ruby_llm"

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: axn-ruby_llm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kali Donovan
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: axn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0.pre.alpha.4.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0.pre.alpha.4.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Call LLMs from Axn actions using RubyLLM, with structured error handling,
+  optional JSON mode, and cost/token tracking.
+email:
+- kali@teamshares.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/axn-ruby_llm.rb
+- lib/axn/ruby_llm.rb
+- lib/axn/ruby_llm/ask.rb
+- lib/axn/ruby_llm/configuration.rb
+- lib/axn/ruby_llm/rspec.rb
+- lib/axn/ruby_llm/version.rb
+homepage: https://github.com/teamshares/axn-ruby_llm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/teamshares/axn-ruby_llm
+  source_code_uri: https://github.com/teamshares/axn-ruby_llm
+  changelog_uri: https://github.com/teamshares/axn-ruby_llm/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: RubyLLM wrapper for Axn actions
+test_files: []