ruby-mana 0.5.1 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4880a32558b5c8a6d08e18d32893e3ab8ae4f9e00ba97009b7c95525998a28a2
-  data.tar.gz: 1244df8f3307dd271471f5a67d2b4b5439086ae78b63f44e1a0e1ecaecf12a40
+  metadata.gz: '092429bef8965edaeff3896552612b8007c00bc923fa3261961d2408e6f2f3d2'
+  data.tar.gz: 0220ec6d7b2549cff95cb52d46cb04cbe298cc0f8009c352edf32e4368424bf3
 SHA512:
-  metadata.gz: c58a40c28a7adecf324099f056a06ca65710f4ba82f9b035fed5a886be061da9cf70259b8372063cdaf60505febe8253455e874b502312811652dedd013b042c
-  data.tar.gz: 2c2c8887ef9da0f01ec7afc51c432f06fe9684e7b732659b3ae3994976d450fcffbaf0bcdb69344045f578126ee4127ebff891ec0b02d6a17ed9f29e3812a18c
+  metadata.gz: a7d698cf965ed5fa907b1fbed85f09077b0324d9213e507c924ae2913fe9a2acf2897eda0508eb612e5e76a0a47cc3ba700ce4be0f89b1a35727002d503a8635
+  data.tar.gz: 365dfc57ee72353d49a737a468010e3117c760f417d2bb72fe9957d7609e73441d652acca6010aa5675857c2dce85fa8619b755151090cd19a1a59dbe874781b

data/CHANGELOG.md

@@ -1,27 +1,82 @@
 # Changelog
 
-## [0.5.1] - 2026-02-24
+## [0.5.7] - 2026-03-27
 
-### Changed
-- **Engine capability refactor** — replaced three redundant capability flags (`supports_remote_ref?`, `supports_bidirectional?`, `supports_state?`) with a single `execution_engine?` method
-- Clearer semantics: execution engines (Ruby/JS/Python) vs reasoning engines (LLM)
-- Fully backward compatible — old methods still work as derived properties
+### Security
+- **call_func receiver validation** — blocks expression injection (e.g. `ENV['HOME'].to_s`) by requiring simple constant names only
+- **write_var no longer pollutes receiver** — singleton method fallback only for new variables that don't conflict with existing methods
 
-## [0.5.0] - 2026-02-22
+### Fixed
+- Failed LLM calls no longer pollute short-term memory (messages rolled back on exception)
+- Logger extracted from engine.rb (726→639 lines)
+- Compiler cache includes sibling function signatures (dependency changes invalidate cache)
+- Summarize error handling: ConfigError propagates, others log
+- OpenAI convert_tools filters $schema key
+- docs/index.html version badge, mock example, context_window default
+
+### Added
+- `Backends::Base` class with shared HTTP infrastructure
+- `Logger` module extracted from Engine
+- Tests for read_attr/write_attr error paths, nested error recovery, mixin visibility
+- Examples: yard_comments.rb, testing.rb
+
+## [0.5.6] - 2026-03-26
 
 ### Added
-- **Polyglot engine architecture** — run Ruby, JavaScript, and Python code side by side
-- JavaScript engine via `mini_racer` with automatic variable bridging
-- Python engine via `pycall` with automatic variable bridging
-- Bidirectional Python ↔ Ruby calling through pycall bridge
-- Engine interface abstraction (`Mana::Engines::Base`)
-- Language auto-detection for polyglot dispatch
+- **Function comment extraction** — descriptions and @param types from YARD-style comments
+- **Keyword argument support** in call_func (kwargs field)
+- **Prism AST prompt extraction** — replaces regex, handles multi-line and escaped quotes
+- **Instruction sequence fallback** — extracts prompt from bytecode in IRB/eval
+- **Cache version locking** — includes gem version + Ruby version in cache hash
+- **Method visibility preservation** — mana def respects private/protected
+- **Smart log formatting** — code highlighting, auto-summarize long values
+
+### Removed
+- **effect_registry** — replaced by plain Ruby functions with comment extraction
+
+### Fixed
+- Config naming: unified `security` / `security=` (was `security_policy`)
+- Config validation: `validate!` method, timeout=0 blocked
+- Config decoupled from Backends module
+- Compiler: `:nokey` (**nil) parameter handled
+- Compiler: cache works in IRB with auto-invalidation
+
+## [0.5.5] - 2026-03-23
 
-### Changed
-- Refactored LLM logic into `Engines::LLM`, extracted from monolithic core
+### Added
+- **Configurable security policy** — 5 levels from `:sandbox` (0) to `:danger` (4), with fine-grained `allow_receiver`/`block_method` overrides
+- **Environment variable config** — `MANA_MODEL`, `MANA_VERBOSE`, `MANA_TIMEOUT`, `MANA_BACKEND`, `MANA_SECURITY`
+- **Verbose mode** — `c.verbose = true` logs LLM calls, tool usage, and results to stderr
+- **API key validation** — clear `ConfigError` with setup instructions instead of cryptic HTTP 401
+- **Long-term memory deduplication** — identical content is no longer stored twice
+- **Current prompt overrides memory** — explicit priority rule in system prompt
+- **Ruby 4.0 support** — CI tests Ruby 3.3, 3.4, and 4.0
 
 ### Fixed
-- Polyglot engine bug fixes (CodeRabbit review feedback)
+- `write_var` works on Ruby 4.0 without pre-declaring variables (singleton method fallback)
+- Blocked Ruby introspection methods (`methods`, `local_variables`, etc.) in `call_func`
+- LLM retries once when model skips tool calling and returns text only
+- Long-term memory stored in `~/.mana/` instead of platform-specific paths
+- Default model changed to `claude-sonnet-4-6`
+- Compiler uses isolated binding to prevent `generate()` recursion
+- Cache files named by source path with prompt hash validation
+
+### Removed
+- Polyglot engine system (JavaScript, Python, language detection)
+- `mini_racer` and `pycall` dependencies
+- `ObjectRegistry`, `RemoteRef`, engine capability queries
+
+## [0.5.3] - 2026-03-22
+
+### Added
+- **Timeout configuration** — `timeout` option in `Mana.configure` (default: 120 seconds)
+
+## [0.5.2] - 2026-03-22
+
+### Added
+- **API URL endpoint configuration** — `effective_base_url` auto-resolves per backend
+- `ANTHROPIC_API_URL` / `OPENAI_API_URL` environment variables
+- API key fallback: `ANTHROPIC_API_KEY` → `OPENAI_API_KEY`
 
 ## [0.4.0] - 2026-02-22
 
@@ -32,14 +87,12 @@
 
 - Nested prompts — LLM calling LLM
 - Lambda `call_func` support
-- Expanded test coverage
 
 ## [0.3.0] - 2026-02-21
 
 - Automatic memory — context sharing across LLM calls
 - Incognito mode
 - Persistent long-term memory
-- `Mana.session` — shared conversation context across prompts
 
 ## [0.2.0] - 2026-02-20
 

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 carlnoah6
+Copyright (c) 2026 Carl Li
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -28,14 +28,18 @@ Or in your Gemfile:
 gem "ruby-mana"
 ```
 
-Requires Ruby 3.3+ and an API key (Anthropic, OpenAI, or compatible):
+Requires Ruby 3.3+ (including 4.0) and an API key (Anthropic, OpenAI, or compatible):
 
 ```bash
 export ANTHROPIC_API_KEY=your_key_here
+export ANTHROPIC_API_URL=https://api.anthropic.com  # optional, this is the default
 # or
 export OPENAI_API_KEY=your_key_here
+export OPENAI_API_URL=https://api.openai.com        # optional, this is the default
 ```
 
+Supports Ruby 3.3, 3.4, and 4.0 — no API differences between versions.
+
 ## Usage
 
 Prefix any string with `~` to make it an LLM prompt:
@@ -129,18 +133,98 @@ while player_hp > 0 && enemy_hp > 0
 end
 ```
 
+### Nested prompts
+
+Functions called by LLM can themselves contain `~"..."` prompts:
+
+```ruby
+lint = ->(code) { ~"check #{code} for style issues, store in <issues>" }
+# Equivalent to:
+# def lint(code)
+#   ~"check #{code} for style issues, store in <issues>"
+#   issues
+# end
+
+~"review <codebase>, call lint for each file, store report in <report>"
+```
+
+Each nested call gets its own conversation context. The outer LLM only sees the function's return value, keeping its context clean.
+
+### LLM-compiled methods
+
+`mana def` lets LLM generate a method implementation on first call. The generated code is cached as a real `.rb` file — subsequent calls are pure Ruby with zero API overhead.
+
+```ruby
+mana def fibonacci(n)
+  ~"return an array of the first n Fibonacci numbers"
+end
+
+fibonacci(10)  # first call → LLM generates code → cached → executed
+fibonacci(20)  # pure Ruby from .mana_cache/
+
+# View the generated source
+puts Mana.source(:fibonacci)
+# def fibonacci(n)
+#   return [] if n <= 0
+#   return [0] if n == 1
+#   fib = [0, 1]
+#   (2...n).each { |i| fib << fib[i-1] + fib[i-2] }
+#   fib
+# end
+
+# Works in classes too
+class Converter
+  include Mana::Mixin
+
+  mana def celsius_to_fahrenheit(c)
+    ~"convert Celsius to Fahrenheit"
+  end
+end
+```
+
+Generated files live in `.mana_cache/` (add to `.gitignore`, or commit them to skip LLM on CI).
+
 ## Configuration
 
+All options can be set via environment variables (`.env` file) or `Mana.configure`:
+
+```bash
+# .env — just source it: `source .env`
+export ANTHROPIC_API_KEY=sk-your-key-here
+export ANTHROPIC_API_URL=https://api.anthropic.com   # optional, custom endpoint
+export MANA_MODEL=claude-sonnet-4-6                  # default model
+export MANA_VERBOSE=true                             # show LLM interactions
+export MANA_TIMEOUT=120                              # HTTP timeout in seconds
+export MANA_BACKEND=anthropic                        # force backend (anthropic/openai)
+export MANA_SECURITY=standard                        # security level (0-4 or name)
+```
+
+| Environment Variable | Config | Default | Description |
+|---------------------|--------|---------|-------------|
+| `ANTHROPIC_API_KEY` | `c.api_key` | — | API key (required) |
+| `OPENAI_API_KEY` | `c.api_key` | — | Fallback API key |
+| `ANTHROPIC_API_URL` | `c.base_url` | auto-detect | Custom API endpoint |
+| `OPENAI_API_URL` | `c.base_url` | auto-detect | Fallback endpoint |
+| `MANA_MODEL` | `c.model` | `claude-sonnet-4-6` | LLM model name |
+| `MANA_VERBOSE` | `c.verbose` | `false` | Log LLM calls to stderr |
+| `MANA_TIMEOUT` | `c.timeout` | `120` | HTTP timeout (seconds) |
+| `MANA_BACKEND` | `c.backend` | auto-detect | Force `anthropic` or `openai` |
+| `MANA_SECURITY` | `c.security` | `:standard` (2) | Security level: `sandbox`, `strict`, `standard`, `permissive`, `danger` |
+
+Programmatic config (overrides env vars):
+
 ```ruby
 Mana.configure do |c|
-  c.model = "claude-sonnet-4-20250514"
+  c.model = "claude-sonnet-4-6"
   c.temperature = 0
-  c.api_key = ENV["ANTHROPIC_API_KEY"]
-  c.max_iterations = 50
+  c.api_key = "sk-..."
+  c.verbose = true
+  c.timeout = 120
+  c.security = :strict            # security level (0-4 or symbol)
 
   # Memory settings
   c.namespace = "my-project"      # nil = auto-detect from git/pwd
-  c.context_window = 200_000      # nil = auto-detect from model
+  c.context_window = 128_000      # default: 128_000
   c.memory_pressure = 0.7         # compact when tokens exceed 70% of context window
   c.memory_keep_recent = 4        # keep last 4 rounds during compaction
   c.compact_model = nil           # nil = use main model for compaction
@@ -156,7 +240,7 @@ Mana supports Anthropic and OpenAI-compatible APIs (including Ollama, DeepSeek,
 # Anthropic (default for claude-* models)
 Mana.configure do |c|
   c.api_key = ENV["ANTHROPIC_API_KEY"]
-  c.model = "claude-sonnet-4-20250514"
+  c.model = "claude-sonnet-4-6"
 end
 
 # OpenAI
@@ -183,172 +267,167 @@ end
 
 Backend is auto-detected from model name: `claude-*` → Anthropic, everything else → OpenAI.
 
-### Custom effect handlers
+### Security policy
 
-Define your own tools that the LLM can call. Each effect becomes an LLM tool automatically — the block's keyword parameters define the tool's input schema.
+Mana restricts what the LLM can call via security levels (higher = more permissions):
 
-```ruby
-# No params
-Mana.define_effect :get_time do
-  Time.now.to_s
-end
-
-# With params — keyword args become tool parameters
-Mana.define_effect :query_db do |sql:|
-  ActiveRecord::Base.connection.execute(sql).to_a
-end
+| Level | Name | What LLM Can Do | What's Blocked |
+|-------|------|-----------------|----------------|
+| 0 | `:sandbox` | Read/write variables, call user-defined functions only | Everything else |
+| 1 | `:strict` | + safe stdlib (`Time.now`, `Date.today`, `Math.*`) | Filesystem, network, system calls, eval |
+| **2** | **`:standard`** (default) | + read filesystem (`File.read`, `Dir.glob`) | Write/delete files, network, eval |
+| 3 | `:permissive` | + write files, network, require | eval, system/exec/fork |
+| 4 | `:danger` | No restrictions | Nothing |
 
-# With description (optional, recommended)
-Mana.define_effect :search_web,
-  description: "Search the web for information" do |query:, max_results: 5|
-    WebSearch.search(query, limit: max_results)
-  end
+Default is **level 2 (`:standard`)**. Set via config or env var:
 
-# Use in prompts
-~"get the current time and store in <now>"
-~"find recent orders using query_db, store in <orders>"
+```ruby
+Mana.configure { |c| c.security = :standard }
+# or
+Mana.configure { |c| c.security = 2 }
 ```
 
-Built-in effects (`read_var`, `write_var`, `read_attr`, `write_attr`, `call_func`, `done`) are reserved and cannot be overridden.
-
-### Memory — automatic context sharing
-
-Consecutive `~"..."` calls automatically share context. No wrapper block needed:
+Fine-grained overrides:
 
 ```ruby
-~"remember: always translate to Japanese, casual tone"
-~"translate <text1>, store in <result1>"   # uses the preference
-~"translate <text2>, store in <result2>"   # still remembers
-~"which translation was harder? store in <analysis>"  # can reference both
+Mana.configure do |c|
+  c.security = :strict
+  c.security.allow_receiver "File", only: %w[read exist?]
+  c.security.block_method "puts"
+  c.security.block_receiver "Net::HTTP"
+end
 ```
 
-Memory is per-thread and auto-created on the first `~"..."` call.
+### Function discovery
 
-#### Long-term memory
-
-The LLM has a `remember` tool that persists facts across script executions:
+Mana automatically discovers your Ruby functions and makes them available to the LLM. Add comments above your functions for better LLM understanding:
 
 ```ruby
-~"remember that the user prefers concise output"
-# ... later, in a different script execution ...
-~"translate <text>"  # LLM sees the preference in its long-term memory
-```
+# Query the database and return results
+# @param sql [String] the SQL query
+# @param limit [Integer] maximum rows to return
+def query_db(sql:, limit: 10)
+  ActiveRecord::Base.connection.execute(sql).first(limit)
+end
 
-Manage long-term memory via Ruby:
+# Search the web for information
+# @param query [String] search keywords
+def search_web(query:)
+  WebSearch.search(query)
+end
 
-```ruby
-Mana.memory.long_term          # view all memories
-Mana.memory.forget(id: 2)     # remove a specific memory
-Mana.memory.clear_long_term!   # clear all long-term memories
-Mana.memory.clear_short_term!  # clear conversation history
-Mana.memory.clear!             # clear everything
+~"use query_db to find recent orders, store in <orders>"
+~"search_web for 'ruby mana gem', store in <results>"
 ```
 
-#### Incognito mode
-
-Run without any memory — nothing is loaded or saved:
-
-```ruby
-Mana.incognito do
-  ~"translate <text>"  # no memory, no persistence
-end
+The LLM sees:
+```
+Available Ruby functions:
+  query_db(sql:, limit: ...) — Query the database and return results
+  search_web(query:) — Search the web for information
 ```
 
-### Polyglot — Cross-Language Interop
+Both positional and keyword arguments are supported. Functions are discovered from the source file (via Prism AST) and from methods defined on `self`.
 
-`~"..."` is a universal operator. It detects whether the code is JavaScript, Python, Ruby, or natural language, and routes to the appropriate engine. Variables bridge automatically.
+### Memory
 
-#### JavaScript
+Mana has two types of memory:
 
-```ruby
-require "mana"
+- **Short-term memory** — conversation history within the current process. Each `~"..."` call appends to it, so consecutive calls share context. Cleared when the process exits.
+- **Long-term memory** — persistent facts stored on disk. Survives across script executions. The LLM can save facts via the `remember` tool.
 
-data = [1, 2, 3, 4, 5]
+#### Short-term memory (conversation context)
 
-# JavaScript — auto-detected from syntax
-~"const evens = data.filter(n => n % 2 === 0)"
-puts evens  # => [2, 4]
+Consecutive `~"..."` calls automatically share context. No wrapper block needed:
 
-# Multi-line with heredoc
-~<<~JS
-  const sum = evens.reduce((a, b) => a + b, 0)
-  const avg = sum / evens.length
-JS
-puts avg  # => 3.0
+```ruby
+~"translate <text1> to Japanese, store in <result1>"
+~"translate <text2> to the same language, store in <result2>"   # remembers "Japanese"
+~"which translation was harder? store in <analysis>"            # can reference both
 ```
 
-#### Python
+Short-term memory is per-thread and auto-created on the first `~"..."` call.
 
 ```ruby
-# Python — auto-detected
-~"evens = [n for n in data if n % 2 == 0]"
-puts evens  # => [2, 4]
-
-# Multi-line
-~<<~PY
-  import statistics
-  mean = statistics.mean(data)
-  stdev = statistics.stdev(data)
-PY
-puts mean   # => 3.0
+Mana.memory.short_term         # view conversation history
+Mana.memory.clear_short_term!  # clear conversation history
 ```
 
-#### Natural language (LLM) — existing behavior
+#### Long-term memory (persistent facts)
+
+The LLM has a `remember` tool that persists facts to disk. These survive across script executions:
 
 ```ruby
-~"analyze <data> and find outliers, store in <result>"
-puts result
-```
+# script_1.rb
+~"remember that the user prefers concise output"
 
-#### How detection works
+# script_2.rb (later, separate execution)
+~"translate <text>"  # LLM sees "user prefers concise output" in long-term memory
+```
 
-- Auto-detects from code syntax (token patterns)
-- Context-aware: consecutive `~"..."` calls tend to stay in the same language
-- Override with `Mana.engine = :javascript` or `Mana.with(:python) { ... }`
-- Detection rules are defined in `data/lang-rules.yml` — transparent, no black box
+Identical content is automatically deduplicated.
 
-#### Variable bridging
+```ruby
+Mana.memory.long_term          # view all persisted facts
+Mana.memory.forget(id: 2)     # remove a specific fact
+Mana.memory.clear_long_term!   # clear all long-term memory
+Mana.memory.clear!             # clear both short-term and long-term
+```
 
-- Simple types (numbers, strings, booleans, nil, arrays, hashes) are copied
-- Each engine maintains a persistent context (V8 for JS, Python interpreter for Python)
-- Variables created in one `~"..."` call persist for the next call in the same engine
+#### Incognito mode
 
-#### Setup
+Run without any memory — nothing is loaded or saved:
 
 ```ruby
-# Gemfile
-gem "mana"
-gem "mini_racer"  # for JavaScript support (optional)
-gem "pycall"      # for Python support (optional)
+Mana.incognito do
+  ~"translate <text>"  # no memory, no persistence
+end
 ```
 
+
 ### Testing
 
 Use `Mana.mock` to test code that uses `~"..."` without calling any API:
 
 ```ruby
-require "mana/test"
+require "mana"
 
 RSpec.describe MyApp do
   include Mana::TestHelpers
 
-  it "analyzes code" do
+  it "writes variables into caller scope" do
+    # Each key becomes a local variable via write_var
     mock_prompt "analyze", bugs: ["XSS"], score: 8.5
 
-    result = MyApp.analyze("user_input")
-    expect(result[:bugs]).to include("XSS")
+    ~"analyze <code> and store bugs in <bugs> and score in <score>"
+    expect(bugs).to eq(["XSS"])
+    expect(score).to eq(8.5)
   end
 
-  it "translates with dynamic response" do
-    mock_prompt(/translate.*to\s+\w+/) do |prompt|
+  it "returns a value via _return" do
+    mock_prompt "translate", _return: "你好"
+
+    result = ~"translate hello to Chinese"
+    expect(result).to eq("你好")
+  end
+
+  it "uses block for dynamic responses" do
+    mock_prompt(/translate/) do |prompt|
       { output: prompt.include?("Chinese") ? "你好" : "hello" }
     end
 
-    expect(MyApp.translate("hi", "Chinese")).to eq("你好")
+    ~"translate hi to Chinese, store in <output>"
+    expect(output).to eq("你好")
   end
 end
 ```
 
+**How mock works:**
+- `mock_prompt(pattern, key: value, ...)` — each key/value pair is written as a local variable (simulates `write_var`)
+- `_return:` — special key, becomes the return value of `~"..."`
+- Block form — receives the prompt text, returns a hash of variables to write
+- Pattern matching: `String` uses `include?`, `Regexp` uses `match?`
+
 Block mode for inline tests:
 
 ```ruby
@@ -363,59 +442,6 @@ end
 
 Unmatched prompts raise `Mana::MockError` with a helpful message suggesting the stub to add.
 
-### Nested prompts
-
-Functions called by LLM can themselves contain `~"..."` prompts:
-
-```ruby
-lint = ->(code) { ~"check #{code} for style issues, store in <issues>" }
-# Equivalent to:
-# def lint(code)
-#   ~"check #{code} for style issues, store in <issues>"
-#   issues
-# end
-
-~"review <codebase>, call lint for each file, store report in <report>"
-```
-
-Each nested call gets its own conversation context. The outer LLM only sees the function's return value, keeping its context clean.
-
-### LLM-compiled methods
-
-`mana def` lets LLM generate a method implementation on first call. The generated code is cached as a real `.rb` file — subsequent calls are pure Ruby with zero API overhead.
-
-```ruby
-mana def fizzbuzz(n)
-  ~"return an array of FizzBuzz results from 1 to n"
-end
-
-fizzbuzz(15)  # first call → LLM generates code → cached → executed
-fizzbuzz(20)  # pure Ruby from .mana_cache/fizzbuzz.rb
-
-# View the generated source
-puts Mana.source(:fizzbuzz)
-# def fizzbuzz(n)
-#   (1..n).map do |i|
-#     if i % 15 == 0 then "FizzBuzz"
-#     elsif i % 3 == 0 then "Fizz"
-#     elsif i % 5 == 0 then "Buzz"
-#     else i.to_s
-#     end
-#   end
-# end
-
-# Works in classes too
-class Converter
-  include Mana::Mixin
-
-  mana def celsius_to_fahrenheit(c)
-    ~"convert Celsius to Fahrenheit"
-  end
-end
-```
-
-Generated files live in `.mana_cache/` (add to `.gitignore`, or commit them to skip LLM on CI).
-
 ## How it works
 
 1. `~"..."` calls `String#~@`, which captures the caller's `Binding`
@@ -426,9 +452,6 @@ Generated files live in `.mana_cache/` (add to `.gitignore`, or commit them to s
 6. Loop until LLM calls `done` or returns without tool calls
 7. After completion, memory compaction runs in background if context is getting large
 
-## Safety
-
-⚠️ Mana executes LLM-generated operations against your live Ruby state. Use with the same caution as `eval`.
 
 ## License
 

data/lib/mana/backends/anthropic.rb

@@ -1,36 +1,18 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
-
 module Mana
   module Backends
+    # Native Anthropic Claude backend.
+    #
+    # Sends requests directly to the Anthropic Messages API (/v1/messages).
+    # No format conversion needed — Mana's internal format matches Anthropic's.
     class Anthropic < Base
       def chat(system:, messages:, tools:, model:, max_tokens: 4096)
-        uri = URI("#{@config.base_url}/v1/messages")
-        body = {
-          model: model,
-          max_tokens: max_tokens,
-          system: system,
-          tools: tools,
-          messages: messages
-        }
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        http.read_timeout = 120
-
-        req = Net::HTTP::Post.new(uri)
-        req["Content-Type"] = "application/json"
-        req["x-api-key"] = @config.api_key
-        req["anthropic-version"] = "2023-06-01"
-        req.body = JSON.generate(body)
-
-        res = http.request(req)
-        raise LLMError, "HTTP #{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
-
-        parsed = JSON.parse(res.body, symbolize_names: true)
+        uri = URI("#{@config.effective_base_url}/v1/messages")
+        parsed = http_post(uri, { model:, max_tokens:, system:, tools:, messages: }, {
+          "x-api-key" => @config.api_key,
+          "anthropic-version" => "2023-06-01"
+        })
         parsed[:content] || []
       end
     end