ruby_llm_mesh 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0f335121a2c16a9ca428f4d5110b69f6caf999d4534358cd6c68d668382c9130
+  data.tar.gz: ec867f6d775e2ba68d5922136ebc7e6a3af52dbf213fad8016c0f613e92a25ca
+SHA512:
+  metadata.gz: 4c094b33bdaa1f55997d3f3719d25d4591b0daeaf23930e6868dab33b65a745560fc6bc43aadd711303d3b8cbb12ce4856f149825104d8d96401b2818c340ec7
+  data.tar.gz: 1b99d7efe252cacc5074257ac8c950d5bd6e84d68beb5a15edd3bc05c64c0499283a98befdfa74a09a2494182e6d68690a1ab69710a799a08bef9b924fd087c1

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-08-07
+
+### Added
+
+- Unified multi-provider routing via `RubyLlmMesh.complete` / `AiAgentRouter.complete`
+- Providers: OpenAI, Anthropic, and OpenAI-compatible local nodes (Ollama, LM Studio, vLLM, etc.)
+- Per-provider circuit breaker with configurable failure threshold and reset timeout
+- Automatic fallback across a provider ladder
+- RAG helpers: text chunker, bag-of-words embeddings, tool schema adapters
+- Optional ActiveRecord `acts_as_ai_agent` for memory, semantic cache, and audit logging
+- Rails railtie that loads only when Rails is present
+
+[0.1.0]: https://github.com/theworker02/ruby_llm_mesh/releases/tag/v0.1.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,63 @@
+# 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.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by opening a GitHub issue or contacting the maintainers via the
+repository. All complaints will be reviewed and investigated promptly and fairly.
+
+## 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.
+
+[homepage]: https://www.contributor-covenant.org

data/CONTRIBUTING.md

@@ -0,0 +1,39 @@
+# Contributing to ruby_llm_mesh
+
+Thanks for your interest in improving this gem.
+
+## Development setup
+
+```bash
+git clone https://github.com/theworker02/ruby_llm_mesh.git
+cd ruby_llm_mesh
+bundle install
+bundle exec rake test
+```
+
+## Guidelines
+
+1. Open an issue before large API changes.
+2. Prefer focused pull requests with tests for new behavior.
+3. Keep the public DSL (`AiAgentRouter` / `RubyLlmMesh`) stable unless a major version bump is intentional.
+4. Do not commit API keys, credentials, or local `.env` files.
+5. Follow the existing code style (frozen string literals, clear error types).
+
+## Testing
+
+Unit tests must not require live provider credentials. Stub HTTP with WebMock or inject stub providers.
+
+```bash
+bundle exec rake test
+```
+
+## Releases
+
+Maintainers cut releases by tagging `vX.Y.Z` on `main`, which triggers the
+RubyGems Trusted Publisher workflow (`.github/workflows/push_gem.yml`).
+
+See the README for Trusted Publisher setup details.
+
+## Code of Conduct
+
+By participating, you agree to uphold our [Code of Conduct](CODE_OF_CONDUCT.md).

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "minitest", "~> 5.25"
+gem "rake", "~> 13.2"
+gem "webmock", "~> 3.24"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 theworker02
+
+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,177 @@
+<p align="center">
+  <img src="assets/logo.png" alt="ruby_llm_mesh logo" width="160" />
+</p>
+
+<h1 align="center">ruby_llm_mesh</h1>
+
+<p align="center">
+  Unified multi-provider AI routing for Ruby &amp; Rails<br/>
+  <code>AiAgentRouter</code> · circuit breaking · fallback · RAG helpers
+</p>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/ruby_llm_mesh"><img src="https://img.shields.io/gem/v/ruby_llm_mesh?color=9B1B30" alt="Gem Version" /></a>
+  <a href="https://github.com/theworker02/ruby_llm_mesh/actions/workflows/ci.yml"><img src="https://github.com/theworker02/ruby_llm_mesh/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-MIT-E85D4C" alt="License: MIT" /></a>
+  <a href="https://theworker02.github.io/ruby_llm_mesh/"><img src="https://img.shields.io/badge/docs-GitHub%20Pages-1A1A1A" alt="GitHub Pages" /></a>
+</p>
+
+**Official RubyGems page:** [https://rubygems.org/gems/ruby_llm_mesh](https://rubygems.org/gems/ruby_llm_mesh)
+
+## What it does
+
+`ruby_llm_mesh` routes prompts across OpenAI, Anthropic, and local OpenAI-compatible nodes with a single DSL. When a provider fails or its circuit is open, the router can fall through the rest of the ladder. Lightweight RAG helpers and an optional ActiveRecord mixin are included for Rails apps.
+
+## Install
+
+```bash
+gem install ruby_llm_mesh
+```
+
+Or in a Gemfile:
+
+```ruby
+gem "ruby_llm_mesh"
+```
+
+Then `bundle install`.
+
+## Quickstart
+
+```ruby
+require "ruby_llm_mesh"
+
+AiAgentRouter.configure do |c|
+  c.openai_api_key = ENV["OPENAI_API_KEY"]
+  c.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+  c.local_node_base_url = "http://127.0.0.1:11434"
+  c.default_providers = %i[anthropic openai local_node]
+  c.fallback = true
+end
+
+response = AiAgentRouter.complete(
+  prompt: "Summarize circuit breakers in one sentence.",
+  providers: %i[anthropic openai local_node],
+  fallback: true
+)
+
+puts response.content
+puts response.provider      # => :anthropic (or next healthy provider)
+puts response.fallback_used # => true if a later provider was used
+```
+
+`RubyLlmMesh.complete` is the same entry point; `AiAgentRouter` is the public product alias.
+
+## Configuration
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `default_providers` | `%i[openai anthropic local_node]` | Provider ladder order |
+| `fallback` | `true` | Continue to next provider on failure |
+| `timeout` | `30` | HTTP open/read timeout (seconds) |
+| `openai_api_key` / `openai_base_url` / `openai_model` | env / `https://api.openai.com/v1` / `gpt-4o-mini` | OpenAI settings |
+| `anthropic_api_key` / `anthropic_base_url` / `anthropic_model` | env / `https://api.anthropic.com` / `claude-sonnet-4-5` | Anthropic settings |
+| `local_node_base_url` / `local_node_model` | `http://127.0.0.1:11434` / `llama3.2` | Local node settings |
+| `circuit_failure_threshold` | `3` | Failures before opening a circuit |
+| `circuit_reset_timeout` | `60` | Seconds before half-open retry |
+| `logger` | `nil` | Object responding to `#info` / `#warn` / `#error` or `#call` |
+
+Environment variables (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `LOCAL_NODE_BASE_URL`, etc.) are read automatically when present.
+
+## Providers
+
+- **`:openai`** — Chat Completions API
+- **`:anthropic`** — Messages API
+- **`:local_node`** — OpenAI-compatible `/v1/chat/completions`, with a fallback to Ollama’s `/api/chat` on 404
+
+Unknown providers raise `RubyLlmMesh::ProviderError` and are skipped in the ladder when fallback is enabled.
+
+## Circuit breaker & fallback
+
+Each provider has an independent circuit. After `circuit_failure_threshold` consecutive failures (or a failure while half-open), the circuit opens for `circuit_reset_timeout` seconds. Open circuits are skipped; the router continues down the ladder when `fallback: true`.
+
+If every provider fails, `RubyLlmMesh::AllProvidersFailedError` is raised with a per-provider error map.
+
+```ruby
+breaker = RubyLlmMesh::Router.circuit_breaker
+breaker.state_for(:openai) # => :closed | :open | :half_open
+RubyLlmMesh::Router.reset_circuit_breaker!
+```
+
+## RAG helpers
+
+```ruby
+chunks = RubyLlmMesh::Rag::Chunker.new(size: 500, overlap: 50).chunk(long_text)
+
+embedder = RubyLlmMesh::Rag::Embeddings.new(dimensions: 256)
+hits = embedder.top_k("billing refunds", documents, k: 3)
+
+tool = RubyLlmMesh::Rag::Tools.define(
+  name: "lookup_order",
+  description: "Fetch an order by id",
+  parameters: { order_id: { type: "string" } },
+  required: [:order_id]
+)
+openai_tools = RubyLlmMesh::Rag::Tools.for_openai([tool])
+```
+
+The built-in embedder is a local bag-of-words helper for prototyping. Swap in a production embedding API when you need higher quality vectors.
+
+## Rails: `acts_as_ai_agent`
+
+The railtie loads only when Rails is present. On ActiveRecord models:
+
+```ruby
+class Conversation < ApplicationRecord
+  acts_as_ai_agent
+  # expects JSON/text columns: messages, semantic_cache, ai_audits (configurable)
+end
+
+conversation = Conversation.create!
+response = conversation.ai_complete("What did we discuss last?", providers: %i[openai])
+```
+
+Hooks provide conversational memory, a simple prompt→response cache, and an audit trail. Attribute names are configurable via `acts_as_ai_agent(memory_attribute:, cache_attribute:, audit_attribute:)`.
+
+## Branding
+
+Primary colors from the project logo:
+
+| Token | Hex |
+|-------|-----|
+| Ruby | `#9B1B30` |
+| Coral | `#E85D4C` |
+| Charcoal | `#1A1A1A` |
+
+Docs site: [https://theworker02.github.io/ruby_llm_mesh/](https://theworker02.github.io/ruby_llm_mesh/)
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Trusted publishing (RubyGems)
+
+Releases are intended to publish via [RubyGems Trusted Publishing](https://guides.rubygems.org/trusted-publishing/) using `.github/workflows/push_gem.yml` on tags matching `v*`.
+
+Configure a **pending trusted publisher** (first release) or trusted publisher at:
+
+[https://rubygems.org/profile/oidc_pending_trusted_publishers](https://rubygems.org/profile/oidc_pending_trusted_publishers)
+
+| Field | Value |
+|-------|-------|
+| Gem name | `ruby_llm_mesh` |
+| GitHub repository owner | `theworker02` |
+| GitHub repository name | `ruby_llm_mesh` |
+| Workflow filename | `push_gem.yml` |
+| Environment name | `release` |
+
+Also create a GitHub Environment named `release` on the repository (Settings → Environments). Pushing tag `v0.1.0` (or later) runs the workflow with `id-token: write` and publishes via `rubygems/release-gem`.
+
+## License
+
+MIT — see [LICENSE.txt](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.warning = true
+end
+
+task default: :test

data/lib/ruby_llm_mesh/active_record/acts_as_ai_agent.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  module ActiveRecord
+    # Optional Rails hooks for conversational memory, semantic caching, and audit logs.
+    #
+    #   class Conversation < ApplicationRecord
+    #     acts_as_ai_agent
+    #   end
+    module ActsAsAiAgent
+      def acts_as_ai_agent(memory_attribute: :messages, cache_attribute: :semantic_cache, audit_attribute: :ai_audits)
+        class_attribute :ai_agent_memory_attribute, instance_writer: false
+        class_attribute :ai_agent_cache_attribute, instance_writer: false
+        class_attribute :ai_agent_audit_attribute, instance_writer: false
+
+        self.ai_agent_memory_attribute = memory_attribute
+        self.ai_agent_cache_attribute = cache_attribute
+        self.ai_agent_audit_attribute = audit_attribute
+
+        include InstanceMethods
+      end
+
+      module InstanceMethods
+        def ai_complete(prompt, **options)
+          cached = ai_semantic_lookup(prompt)
+          return cached if cached
+
+          memory = ai_memory
+          system = options.delete(:system)
+          system = [system, "Conversation memory:\n#{memory.join("\n")}"].compact.join("\n\n") unless memory.empty?
+
+          response = RubyLlmMesh.complete(prompt: prompt, system: system, **options)
+          ai_remember!(role: "user", content: prompt)
+          ai_remember!(role: "assistant", content: response.content, provider: response.provider)
+          ai_cache!(prompt, response)
+          ai_audit!(prompt, response)
+          response
+        end
+
+        def ai_memory
+          raw = read_ai_json(self.class.ai_agent_memory_attribute)
+          Array(raw)
+        end
+
+        def ai_remember!(entry)
+          memory = ai_memory
+          memory << entry.transform_keys(&:to_s)
+          write_ai_json(self.class.ai_agent_memory_attribute, memory)
+          save if respond_to?(:save)
+        end
+
+        def ai_clear_memory!
+          write_ai_json(self.class.ai_agent_memory_attribute, [])
+          save if respond_to?(:save)
+        end
+
+        def ai_semantic_lookup(prompt)
+          cache = read_ai_json(self.class.ai_agent_cache_attribute)
+          return nil unless cache.is_a?(Hash)
+
+          entry = cache[prompt.to_s]
+          return nil unless entry
+
+          RubyLlmMesh::Response.new(
+            content: entry["content"],
+            provider: (entry["provider"] || :cache).to_sym,
+            model: entry["model"],
+            usage: entry["usage"] || {},
+            latency_ms: 0,
+            fallback_used: false
+          )
+        end
+
+        def ai_cache!(prompt, response)
+          cache = read_ai_json(self.class.ai_agent_cache_attribute)
+          cache = {} unless cache.is_a?(Hash)
+          cache[prompt.to_s] = {
+            "content" => response.content,
+            "provider" => response.provider.to_s,
+            "model" => response.model,
+            "usage" => response.usage
+          }
+          write_ai_json(self.class.ai_agent_cache_attribute, cache)
+        end
+
+        def ai_audit!(prompt, response)
+          audits = read_ai_json(self.class.ai_agent_audit_attribute)
+          audits = [] unless audits.is_a?(Array)
+          audits << {
+            "at" => Time.now.utc.iso8601,
+            "prompt" => prompt.to_s,
+            "provider" => response.provider.to_s,
+            "model" => response.model,
+            "latency_ms" => response.latency_ms,
+            "fallback_used" => response.fallback_used
+          }
+          write_ai_json(self.class.ai_agent_audit_attribute, audits)
+        end
+
+        private
+
+        def read_ai_json(attr)
+          return [] unless respond_to?(attr)
+
+          value = public_send(attr)
+          return value if value.is_a?(Array) || value.is_a?(Hash)
+          return JSON.parse(value) if value.is_a?(String) && !value.empty?
+
+          value.nil? ? nil : value
+        rescue JSON::ParserError
+          nil
+        end
+
+        def write_ai_json(attr, value)
+          return unless respond_to?("#{attr}=")
+
+          public_send("#{attr}=", value)
+        end
+      end
+    end
+  end
+end
+
+if defined?(::ActiveRecord::Base)
+  ::ActiveRecord::Base.extend(RubyLlmMesh::ActiveRecord::ActsAsAiAgent)
+end

data/lib/ruby_llm_mesh/circuit_breaker.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  # Simple per-provider circuit breaker shared across the process.
+  class CircuitBreaker
+    OPEN = :open
+    CLOSED = :closed
+    HALF_OPEN = :half_open
+
+    def initialize(failure_threshold:, reset_timeout:)
+      @failure_threshold = failure_threshold
+      @reset_timeout = reset_timeout
+      @states = Hash.new { |h, k| h[k] = { failures: 0, opened_at: nil, state: CLOSED } }
+      @mutex = Mutex.new
+    end
+
+    def allow?(provider)
+      @mutex.synchronize do
+        entry = @states[provider]
+        case entry[:state]
+        when CLOSED
+          true
+        when OPEN
+          if Time.now - entry[:opened_at] >= @reset_timeout
+            entry[:state] = HALF_OPEN
+            true
+          else
+            false
+          end
+        when HALF_OPEN
+          true
+        end
+      end
+    end
+
+    def record_success(provider)
+      @mutex.synchronize do
+        @states[provider] = { failures: 0, opened_at: nil, state: CLOSED }
+      end
+    end
+
+    def record_failure(provider)
+      @mutex.synchronize do
+        entry = @states[provider]
+        entry[:failures] += 1
+        if entry[:failures] >= @failure_threshold || entry[:state] == HALF_OPEN
+          entry[:state] = OPEN
+          entry[:opened_at] = Time.now
+        end
+      end
+    end
+
+    def state_for(provider)
+      @mutex.synchronize { @states[provider][:state] }
+    end
+
+    def reset!(provider = nil)
+      @mutex.synchronize do
+        if provider
+          @states.delete(provider)
+        else
+          @states.clear
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm_mesh/configuration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  class Configuration
+    attr_accessor :default_providers, :fallback, :timeout, :max_retries,
+                  :openai_api_key, :openai_base_url, :openai_model,
+                  :anthropic_api_key, :anthropic_base_url, :anthropic_model,
+                  :local_node_base_url, :local_node_model,
+                  :circuit_failure_threshold, :circuit_reset_timeout,
+                  :logger
+
+    def initialize
+      @default_providers = %i[openai anthropic local_node]
+      @fallback = true
+      @timeout = 30
+      @max_retries = 1
+
+      @openai_api_key = ENV.fetch("OPENAI_API_KEY", nil)
+      @openai_base_url = ENV.fetch("OPENAI_BASE_URL", "https://api.openai.com/v1")
+      @openai_model = ENV.fetch("OPENAI_MODEL", "gpt-4o-mini")
+
+      @anthropic_api_key = ENV.fetch("ANTHROPIC_API_KEY", nil)
+      @anthropic_base_url = ENV.fetch("ANTHROPIC_BASE_URL", "https://api.anthropic.com")
+      @anthropic_model = ENV.fetch("ANTHROPIC_MODEL", "claude-sonnet-4-5")
+
+      @local_node_base_url = ENV.fetch("LOCAL_NODE_BASE_URL", "http://127.0.0.1:11434")
+      @local_node_model = ENV.fetch("LOCAL_NODE_MODEL", "llama3.2")
+
+      @circuit_failure_threshold = 3
+      @circuit_reset_timeout = 60
+      @logger = nil
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/ruby_llm_mesh/errors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  class ProviderError < Error
+    attr_reader :provider, :status, :body
+
+    def initialize(message, provider: nil, status: nil, body: nil)
+      @provider = provider
+      @status = status
+      @body = body
+      super(message)
+    end
+  end
+
+  class RateLimitError < ProviderError; end
+  class TimeoutError < ProviderError; end
+  class AuthenticationError < ProviderError; end
+  class CircuitOpenError < ProviderError; end
+
+  class AllProvidersFailedError < Error
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      summary = errors.map { |provider, err| "#{provider}: #{err.message}" }.join("; ")
+      super("All providers failed — #{summary}")
+    end
+  end
+end

data/lib/ruby_llm_mesh/providers/anthropic.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  module Providers
+    class Anthropic < Base
+      def name
+        :anthropic
+      end
+
+      def complete(prompt:, system: nil, model: nil, **options)
+        api_key = config.anthropic_api_key
+        raise AuthenticationError.new("ANTHROPIC_API_KEY is not configured", provider: name) if api_key.to_s.empty?
+
+        model ||= config.anthropic_model
+        body = {
+          model: model,
+          max_tokens: options.fetch(:max_tokens, 1024),
+          messages: [{ role: "user", content: prompt }]
+        }
+        body[:system] = system if system
+        body[:temperature] = options[:temperature] if options.key?(:temperature)
+        body[:tools] = options[:tools] if options[:tools]
+
+        response, latency_ms = http_post(
+          "#{config.anthropic_base_url.chomp('/')}/v1/messages",
+          headers: {
+            "x-api-key" => api_key,
+            "anthropic-version" => "2023-06-01",
+            "Content-Type" => "application/json"
+          },
+          body: body
+        )
+
+        raise_for_status!(response)
+        data = parse_json(response)
+        content = Array(data["content"]).map { |block| block["text"] }.compact.join
+
+        Response.new(
+          content: content,
+          provider: name,
+          model: data["model"] || model,
+          usage: data["usage"] || {},
+          raw: data,
+          latency_ms: latency_ms
+        )
+      end
+    end
+  end
+end