dspy-anthropic 1.0.4 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b563f892087546b395c4c279b09684339170eb112898941d3129ac48f804cbf
-  data.tar.gz: 54f15263e44abd8b6feca18a9569973ee952c6dd9373e4302db9ed66e46811c3
+  metadata.gz: b8d68b501f25927a814cc35c0af2c7f0e5f3b5bd1bb03f3b48df61111977bdee
+  data.tar.gz: 58af722a168077708cde9ab723d4004c5cf47204adad3e75ece1a15fd25455ce
 SHA512:
-  metadata.gz: e78bbfb62abdd747b2dbf0d31da401078eeab71c09a6411d78097769baae4a8d96f1c142617741b203031ba9494e6b99581d5c4a9dbc81e1c40fe8ca221bffa7
-  data.tar.gz: 9369dadfb40f324a0f27cf8cdb912245ec214a0e13c676865b561a8886f4a12b0059c4e3b0b67b75b923df7e4a3604462b48d0b8a7807508e1641e0f044173e5
+  metadata.gz: c070133fcdac4bfc561c37084bcce94b31a7564ae3e8b872b80593684e105f71dbe80a1c84e06f0cc7971649bbc8d5c66a9d3333f739ed643a5e04f59afffca3
+  data.tar.gz: 1da253c16a11737bb777d49639906ef09afe7b62188d36937bfd405582acc3de318169bfb7b95b41220ae042988f73079028d77f0cb63429f20c9b0793b63813

data/README.md

@@ -6,95 +6,16 @@
 [![Documentation](https://img.shields.io/badge/docs-oss.vicente.services%2Fdspy.rb-blue)](https://oss.vicente.services/dspy.rb/)
 [![Discord](https://img.shields.io/discord/1161519468141355160?label=discord&logo=discord&logoColor=white)](https://discord.gg/zWBhrMqn)
 
-**Build reliable LLM applications in idiomatic Ruby using composable, type-safe modules.**
+**Build typed agents and model-backed programs in Ruby.**
 
-DSPy.rb is the Ruby port of Stanford's [DSPy](https://dspy.ai). Instead of wrestling with brittle prompt strings, you define typed signatures and let the framework handle the rest. Prompts become functions. LLM calls become predictable.
+DSPy.rb brings [DSPy](https://dspy.ai)'s signature, module, agent, and optimizer model to Ruby, with Sorbet types and Ruby-native integrations. A signature declares a task as typed inputs and outputs. A module chooses how to execute it. Ruby composes modules into programs, while `ReAct` adds a bounded loop when the model should choose the next action. DSPy.rb builds the provider request and validates the returned shape.
 
-```ruby
-require 'dspy'
-
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
-end
-
-class Summarize < DSPy::Signature
-  description "Summarize the given text in one sentence."
-
-  input do
-    const :text, String
-  end
-
-  output do
-    const :summary, String
-  end
-end
-
-summarizer = DSPy::Predict.new(Summarize)
-result = summarizer.call(text: "DSPy.rb brings structured LLM programming to Ruby...")
-puts result.summary
-```
-
-That's it. No prompt templates. No JSON parsing. No prayer-based error handling.
-
-## Installation
-
-```ruby
-# Gemfile
-gem 'dspy'
-gem 'dspy-openai'     # For OpenAI, OpenRouter, or Ollama
-# gem 'dspy-anthropic' # For Claude
-# gem 'dspy-gemini'    # For Gemini
-# gem 'dspy-ruby_llm'  # For 12+ providers via RubyLLM
-```
-
-```bash
-bundle install
-```
-
-## Quick Start
-
-### Configure Your LLM
-
-```ruby
-# OpenAI
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
-                      api_key: ENV['OPENAI_API_KEY'],
-                      structured_outputs: true)
-end
-
-# Anthropic Claude
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('anthropic/claude-sonnet-4-20250514',
-                      api_key: ENV['ANTHROPIC_API_KEY'])
-end
-
-# Google Gemini
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('gemini/gemini-2.5-flash',
-                      api_key: ENV['GEMINI_API_KEY'])
-end
-
-# Ollama (local, free)
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('ollama/llama3.2')
-end
-
-# OpenRouter (200+ models)
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openrouter/deepseek/deepseek-chat-v3.1:free',
-                      api_key: ENV['OPENROUTER_API_KEY'])
-end
-```
-
-### Define a Signature
+The `1.x` series is the current stable release line.
 
-Signatures are typed contracts for LLM operations. Define inputs, outputs, and let DSPy handle the prompt:
+In a configured application, the task contract and call look like this:
 
 ```ruby
 class Classify < DSPy::Signature
-  description "Classify sentiment of a given sentence."
-
   class Sentiment < T::Enum
     enums do
       Positive = new('positive')
@@ -104,7 +25,7 @@ class Classify < DSPy::Signature
   end
 
   input do
-    const :sentence, String, description: 'The sentence to analyze'
+    const :sentence, String
   end
 
   output do
@@ -114,107 +35,39 @@ class Classify < DSPy::Signature
 end
 
 classifier = DSPy::Predict.new(Classify)
-result = classifier.call(sentence: "This book was super fun to read!")
-
-result.sentiment    # => #<Sentiment::Positive>
-result.confidence   # => 0.92
+result = classifier.call(sentence: "This book was fun to read!")
 ```
 
-### Chain of Thought
-
-For complex reasoning, use `ChainOfThought` to get step-by-step explanations:
-
-```ruby
-solver = DSPy::ChainOfThought.new(MathProblem)
-result = solver.call(problem: "If a train travels 120km in 2 hours, what's its speed?")
-
-result.reasoning  # => "Speed = Distance / Time = 120km / 2h = 60km/h"
-result.answer     # => "60 km/h"
-```
+Define a typed task contract instead of maintaining an output template. Receive validated Ruby values instead of parsing provider JSON. Handle configuration, transport, and validation errors explicitly.
 
-### ReAct Agents
-
-Build agents that use tools to accomplish tasks:
-
-```ruby
-class SearchTool < DSPy::Tools::Base
-  tool_name "search"
-  tool_description "Search for information"
-
-  sig { params(query: String).returns(String) }
-  def call(query:)
-    # Your search implementation
-    "Result 1, Result 2"
-  end
-end
-
-agent = DSPy::ReAct.new(ResearchTask, tools: [SearchTool.new], max_iterations: 5)
-result = agent.call(question: "What's the latest on Ruby 3.4?")
-```
+## Start Here
 
-## What's Included
+The [Quick Start](https://oss.vicente.services/dspy.rb/getting-started/quick-start/) is the complete supported path: install the core and provider gems, configure a key, save a program, and run it.
 
-**Core Modules**: Predict, ChainOfThought, ReAct agents, and composable pipelines.
+Use [Installation](https://oss.vicente.services/dspy.rb/getting-started/installation/) to choose a provider. The [package and capability matrix](https://oss.vicente.services/dspy.rb/getting-started/packages/) records exact gem names, require behavior, support labels, and model or SDK boundaries.
 
-**Type Safety**: Sorbet-based runtime validation. Enums, unions, nested structs—all work.
+## Mental Model
 
-**Multimodal**: Image analysis with `DSPy::Image` for vision-capable models.
+- A `DSPy::Signature` defines the task contract.
+- `DSPy::Predict` and other modules choose an execution strategy.
+- Ordinary Ruby owns fixed sequencing, branching, persistence, permissions, and failure policy.
+- Results cross a runtime validation boundary; validation establishes shape, not factual correctness.
 
-**Observability**: Zero-config Langfuse integration via OpenTelemetry. Non-blocking, production-ready.
-
-**Optimization**: MIPROv2 (Bayesian optimization) and GEPA (genetic evolution) for prompt tuning.
-
-**Provider Support**: OpenAI, Anthropic, Gemini, Ollama, and OpenRouter via official SDKs.
-
-## Documentation
-
-**[Full Documentation](https://oss.vicente.services/dspy.rb/)** — Getting started, core concepts, advanced patterns.
-
-**[llms.txt](https://oss.vicente.services/dspy.rb/llms.txt)** — LLM-friendly reference for AI assistants.
-
-### Claude Skill
-
-A [Claude Skill](https://github.com/vicentereig/dspy-rb-skill) is available to help you build DSPy.rb applications:
-
-```bash
-# Claude Code — install from the vicentereig/engineering marketplace
-claude install-skill vicentereig/engineering --skill dspy-rb
-```
-
-For Claude.ai Pro/Max, download the [skill ZIP](https://github.com/vicentereig/dspy-rb-skill/archive/refs/heads/main.zip) and upload via Settings > Skills.
-
-## Examples
-
-The [examples/](examples/) directory has runnable code for common patterns:
-
-- Sentiment classification
-- ReAct agents with tools
-- Image analysis
-- Prompt optimization
-
-```bash
-bundle exec ruby examples/basic_search_agent.rb
-```
+### ReAct Agents
 
-## Optional Gems
+Use `ReAct` when the model needs to choose among typed Ruby tools inside an iteration bound. The application still owns tool authorization, side effects, budgets, and errors. See [Predictors](https://oss.vicente.services/dspy.rb/core-concepts/predictors/) and [Toolsets](https://oss.vicente.services/dspy.rb/core-concepts/toolsets/).
 
-DSPy.rb ships sibling gems for features with heavier dependencies. Add them as needed:
+## Explore
 
-| Gem | What it does |
-| --- | --- |
-| `dspy-datasets` | Dataset helpers, Parquet/Polars tooling |
-| `dspy-evals` | Evaluation harness with metrics and callbacks |
-| `dspy-miprov2` | Bayesian optimization for prompt tuning |
-| `dspy-gepa` | Genetic-Pareto prompt evolution |
-| `dspy-o11y-langfuse` | Auto-configure Langfuse tracing |
-| `dspy-code_act` | Think-Code-Observe agents |
-| `dspy-deep_search` | Production DeepSearch with Exa |
+- [Documentation](https://oss.vicente.services/dspy.rb/) — task-oriented guides and reference
+- [Examples](examples/) — repository demos indexed by capability and prerequisites
+- [llms.txt](https://oss.vicente.services/dspy.rb/llms.txt) — generated reference for AI assistants
 
-See [the full list](https://oss.vicente.services/dspy.rb/getting-started/installation/) in the docs.
+Provider adapters, optimizers, observability exporters, datasets, and code-executing agents are separate packages when they add dependencies. Check the package matrix before selecting one; package availability does not guarantee uniform provider or model behavior.
 
 ## Contributing
 
-Feedback is invaluable. If you encounter issues, [open an issue](https://github.com/vicentereig/dspy.rb/issues). For suggestions, [start a discussion](https://github.com/vicentereig/dspy.rb/discussions).
+For bugs, [open an issue](https://github.com/vicentereig/dspy.rb/issues). For suggestions, [start a discussion](https://github.com/vicentereig/dspy.rb/discussions).
 
 Want to contribute code? Reach out: hey at vicente.services
 

data/lib/dspy/anthropic/lm/adapters/anthropic_adapter.rb

@@ -3,20 +3,29 @@
 require 'anthropic'
 require 'dspy/lm/vision_models'
 require 'dspy/lm/adapter'
-
-require 'dspy/anthropic/guardrails'
-DSPy::Anthropic::Guardrails.ensure_anthropic_installed!
+require 'dspy/anthropic/lm/model_capabilities'
 
 module DSPy
   module Anthropic
     module LM
       module Adapters
         class AnthropicAdapter < DSPy::LM::Adapter
-          def initialize(model:, api_key:, structured_outputs: true)
+          # Distinguishes "temperature not passed" from "temperature: nil" so the
+          # implicit default (see #effective_temperature) can be model/reasoning-aware
+          # while still letting callers force an explicit value, including nil.
+          NOT_SET = Object.new.freeze
+
+          def initialize(model:, api_key:, structured_outputs: true, reasoning: nil, temperature: NOT_SET, max_tokens: 4096)
             super(model: model, api_key: api_key)
             validate_api_key!(api_key, 'anthropic')
             @client = ::Anthropic::Client.new(api_key: api_key)
             @structured_outputs_enabled = structured_outputs
+            @capability = DSPy::Anthropic::LM::ModelCapabilities.for(model)
+            @max_tokens = max_tokens
+            @temperature_explicit = !temperature.equal?(NOT_SET)
+            @temperature = @temperature_explicit ? temperature : nil
+            @thinking_param = build_thinking_param(reasoning)
+            @effort_param = build_effort_param(reasoning)
           end
 
           def chat(messages:, signature: nil, **extra_params, &block)
@@ -25,32 +34,48 @@ module DSPy
             # Validate vision support if images are present
             if contains_images?(normalized_messages)
               DSPy::LM::VisionModels.validate_vision_support!('anthropic', model)
-              # Convert messages to Anthropic format with proper image handling
+            end
+
+            # Convert multimodal messages to Anthropic format
+            if contains_media?(normalized_messages)
               normalized_messages = format_multimodal_messages(normalized_messages, 'anthropic')
             end
 
             # Anthropic requires system message to be separate from messages
             system_message, user_messages = extract_system_message(normalized_messages)
 
-            # Extract Beta API parameters if present
             output_format = extra_params.delete(:output_format)
-            betas = extra_params.delete(:betas)
+            extra_params.delete(:betas) # deprecated Beta API param; ignored if a caller still passes it
 
             # Check if this is a tool use request
             has_tools = extra_params.key?(:tools) && !extra_params[:tools].empty?
 
-            # Apply JSON prefilling if needed for better Claude JSON compliance (but not for tool use or Beta API)
-            unless has_tools || output_format || contains_images?(normalized_messages)
+            # Apply JSON prefilling if needed for better Claude JSON compliance (but not for tool use or structured output)
+            unless has_tools || output_format || contains_media?(normalized_messages)
               user_messages = prepare_messages_for_json(user_messages, system_message)
             end
 
+            # A per-call `temperature:` (passed to #chat, e.g. via a strategy or a
+            # direct caller) takes priority over the adapter's own default/effective
+            # temperature — restores pre-#256 override semantics. `nil` here means
+            # "omit the key", same as the constructor-level sentinel.
+            per_call_temperature_given = extra_params.key?(:temperature)
+            per_call_temperature = extra_params.delete(:temperature)
+
             request_params = {
               model: model,
               messages: user_messages,
-              max_tokens: 4096, # Required for Anthropic
-              temperature: 0.0 # DSPy default for deterministic responses
+              max_tokens: @max_tokens
             }.merge(extra_params)
 
+            temperature = per_call_temperature_given ? per_call_temperature : effective_temperature
+            request_params[:temperature] = temperature unless temperature.nil?
+
+            request_params[:thinking] = @thinking_param if @thinking_param
+
+            output_config = build_output_config(output_format)
+            request_params[:output_config] = output_config if output_config
+
             # Add system message if present
             request_params[:system] = system_message if system_message
 
@@ -61,23 +86,17 @@ module DSPy
 
             begin
               if block_given?
+                # Anthropic::Resources::Messages#stream does not accept or
+                # yield to a block itself -- it returns a MessageStream that
+                # the caller consumes via #each/#text. Passing a `do...end`
+                # block directly to #stream (the pre-#259 approach) is
+                # silently discarded by Ruby, so the block body never runs
+                # and `content` never accumulates anything.
                 content = ""
-                if output_format
-                  @client.beta.messages.stream(**request_params, output_format: output_format, betas: betas) do |chunk|
-                    if chunk.respond_to?(:delta) && chunk.delta.respond_to?(:text)
-                      chunk_text = chunk.delta.text
-                      content += chunk_text
-                      block.call(chunk)
-                    end
-                  end
-                else
-                  @client.messages.stream(**request_params) do |chunk|
-                    if chunk.respond_to?(:delta) && chunk.delta.respond_to?(:text)
-                      chunk_text = chunk.delta.text
-                      content += chunk_text
-                      block.call(chunk)
-                    end
-                  end
+                stream = @client.messages.stream(**request_params)
+                stream.text.each do |text_fragment|
+                  content += text_fragment
+                  block.call(text_fragment)
                 end
 
                 # Create typed metadata for streaming response
@@ -92,11 +111,7 @@ module DSPy
                   metadata: metadata
                 )
               else
-                response = if output_format
-                  @client.beta.messages.create(**request_params, output_format: output_format, betas: betas)
-                else
-                  @client.messages.create(**request_params)
-                end
+                response = @client.messages.create(**request_params)
 
                 if response.respond_to?(:error) && response.error
                   raise DSPy::LM::AdapterError, "Anthropic API error: #{response.error}"
@@ -168,6 +183,117 @@ module DSPy
 
           private
 
+          # Merges structured-output format and reasoning effort into the single
+          # `output_config` shape Anthropic expects (replaces the deprecated
+          # `output_format`/`betas` Beta API params).
+          def build_output_config(output_format)
+            config = {}
+            config[:format] = output_format if output_format
+            config[:effort] = @effort_param if @effort_param
+            config.empty? ? nil : config
+          end
+
+          # `nil` reasoning => no `thinking` param at all (classic behavior).
+          #
+          # Effort-only reasoning (.low/.medium/.high/.xhigh/.max) normally
+          # returns nil here too — #build_effort_param/#build_output_config
+          # handle `output_config.effort` on their own. The one exception is
+          # "opt-in adaptive" model families (Opus 4.7/4.8, Opus/Sonnet 4.6):
+          # per Anthropic's docs, those models run *without* thinking unless
+          # `thinking: { type: "adaptive" }` is explicitly set, regardless of
+          # `output_config.effort`. Without this, `DSPy::Reasoning.high` would
+          # silently not enable any actual reasoning on those models — see
+          # PR #257 review.
+          def build_thinking_param(reasoning)
+            return nil if reasoning.nil?
+
+            if reasoning.budget_tokens
+              validate_manual_budget!(reasoning.budget_tokens)
+              { type: :enabled, budget_tokens: reasoning.budget_tokens }
+            elsif reasoning.adaptive
+              validate_adaptive!
+              { type: :adaptive }
+            elsif reasoning.disabled
+              validate_thinking_disable!
+              { type: :disabled }
+            elsif reasoning.effort && @capability.adaptive_thinking == :opt_in
+              { type: :adaptive }
+            end
+          end
+
+          def build_effort_param(reasoning)
+            return nil unless reasoning&.effort
+
+            validate_effort!(reasoning.effort)
+            reasoning.effort.serialize.to_sym
+          end
+
+          def validate_manual_budget!(budget_tokens)
+            if @capability.manual_budget == false
+              raise DSPy::LM::ConfigurationError,
+                "#{model} does not support manual thinking budgets (DSPy::Reasoning.budget). " \
+                "This model only supports adaptive thinking; use DSPy::Reasoning.adaptive or an effort tier instead."
+            end
+
+            if budget_tokens < 1024
+              raise DSPy::LM::ConfigurationError,
+                "budget_tokens must be >= 1024 (Anthropic's documented minimum), got #{budget_tokens}."
+            end
+
+            if budget_tokens >= @max_tokens
+              raise DSPy::LM::ConfigurationError,
+                "budget_tokens (#{budget_tokens}) must be less than max_tokens (#{@max_tokens}). " \
+                "Increase max_tokens: when constructing DSPy::LM, or lower the requested budget."
+            end
+          end
+
+          def validate_adaptive!
+            if @capability.adaptive_thinking == false
+              raise DSPy::LM::ConfigurationError,
+                "#{model} does not support adaptive thinking. Use DSPy::Reasoning.budget(tokens) instead."
+            end
+          end
+
+          def validate_thinking_disable!
+            unless @capability.thinking_disable
+              raise DSPy::LM::ConfigurationError,
+                "#{model} cannot disable extended thinking: it is always on for this model family."
+            end
+          end
+
+          def validate_effort!(effort)
+            unless @capability.effort
+              raise DSPy::LM::ConfigurationError,
+                "#{model} does not support DSPy::Reasoning effort tiers (output_config.effort). " \
+                "This model predates Anthropic's effort parameter."
+            end
+
+            if effort == DSPy::Reasoning::Effort::XHigh && !@capability.xhigh_effort
+              raise DSPy::LM::ConfigurationError, "#{model} does not support DSPy::Reasoning.xhigh."
+            end
+
+            if effort == DSPy::Reasoning::Effort::Max && !@capability.max_effort
+              raise DSPy::LM::ConfigurationError, "#{model} does not support DSPy::Reasoning.max."
+            end
+          end
+
+          # Three-state temperature: explicit value (including nil) always wins;
+          # otherwise omit for models that reject non-default sampling params, or
+          # while extended thinking is actually engaged (Anthropic: "Thinking isn't
+          # compatible with temperature"); otherwise fall back to DSPy's classic
+          # deterministic default.
+          def effective_temperature
+            return @temperature if @temperature_explicit
+            return nil if @capability.fixed_sampling
+            return nil if thinking_active?
+
+            0.0
+          end
+
+          def thinking_active?
+            !@thinking_param.nil? && @thinking_param[:type] != :disabled
+          end
+
           # Enhanced JSON extraction specifically for Claude models
           # Handles multiple patterns of markdown-wrapped JSON responses
           def extract_json_from_response(content)

data/lib/dspy/anthropic/lm/model_capabilities.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module DSPy
+  module Anthropic
+    module LM
+      # Per-model-family reasoning/sampling capabilities.
+      #
+      # Anthropic ships new Claude model generations every few months, each with
+      # different `thinking`/`effort`/sampling-parameter support. Rather than
+      # scatter model-name regexes through the adapter, this registry centralizes
+      # them so validation logic can ask a single question ("does this model
+      # support X?") instead of re-deriving it from the model string each time.
+      #
+      # Source (verified 2026-07-09):
+      # - https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking
+      # - https://platform.claude.com/docs/en/build-with-claude/effort
+      #
+      # Unrecognized models (including future Anthropic releases not yet added
+      # here) fall back to +DEFAULT+: the classic, pre-adaptive-thinking
+      # behavior this gem has always assumed (manual `budget_tokens` only, no
+      # named effort tiers, unrestricted `temperature`). This is a deliberately
+      # conservative choice: it keeps existing behavior for models we don't
+      # know about, at the cost of `DSPy::Reasoning` effort tiers not working
+      # on brand-new models until this registry is updated.
+      module ModelCapabilities
+        Capability = Struct.new(
+          :adaptive_thinking,  # :always_on | :default_on | :opt_in | false
+          :manual_budget,      # true | :deprecated | false
+          :thinking_disable,   # true | false — supports `thinking: {type: 'disabled'}`
+          :effort,             # true | false — supports `output_config.effort` at all
+          :xhigh_effort,       # true | false
+          :max_effort,         # true | false
+          :fixed_sampling,     # true => rejects non-default temperature/top_p/top_k
+          keyword_init: true
+        ) do
+          def to_h
+            {
+              adaptive_thinking: adaptive_thinking,
+              manual_budget: manual_budget,
+              thinking_disable: thinking_disable,
+              effort: effort,
+              xhigh_effort: xhigh_effort,
+              max_effort: max_effort,
+              fixed_sampling: fixed_sampling
+            }
+          end
+        end
+        private_constant :Capability
+
+        FABLE_MYTHOS_5 = Capability.new(
+          adaptive_thinking: :always_on, manual_budget: false, thinking_disable: false,
+          effort: true, xhigh_effort: true, max_effort: true, fixed_sampling: true
+        ).freeze
+
+        # fixed_sampling: true per PR #257 review (vicentereig, 2026-07-11) —
+        # Anthropic documents Mythos Preview as rejecting non-default
+        # temperature/top_p/top_k, same failure class as #256.
+        MYTHOS_PREVIEW = Capability.new(
+          adaptive_thinking: :default_on, manual_budget: true, thinking_disable: false,
+          effort: true, xhigh_effort: false, max_effort: true, fixed_sampling: true
+        ).freeze
+
+        OPUS_4_7_OR_4_8 = Capability.new(
+          adaptive_thinking: :opt_in, manual_budget: false, thinking_disable: true,
+          effort: true, xhigh_effort: true, max_effort: true, fixed_sampling: true
+        ).freeze
+
+        SONNET_5 = Capability.new(
+          adaptive_thinking: :default_on, manual_budget: false, thinking_disable: true,
+          effort: true, xhigh_effort: true, max_effort: true, fixed_sampling: true
+        ).freeze
+
+        OPUS_OR_SONNET_4_6 = Capability.new(
+          adaptive_thinking: :opt_in, manual_budget: :deprecated, thinking_disable: true,
+          effort: true, xhigh_effort: false, max_effort: true, fixed_sampling: false
+        ).freeze
+
+        OPUS_4_5 = Capability.new(
+          adaptive_thinking: false, manual_budget: true, thinking_disable: true,
+          effort: true, xhigh_effort: false, max_effort: false, fixed_sampling: false
+        ).freeze
+
+        # Conservative fallback for any model not explicitly listed above,
+        # including older Claude models and models Anthropic ships after this
+        # file is written. Matches this gem's pre-#256 behavior exactly.
+        DEFAULT = Capability.new(
+          adaptive_thinking: false, manual_budget: true, thinking_disable: true,
+          effort: false, xhigh_effort: false, max_effort: false, fixed_sampling: false
+        ).freeze
+
+        # Ordered [pattern, capability] pairs. Patterns are matched with
+        # `String#match?` against the bare model name (i.e. without the
+        # "anthropic/" provider prefix DSPy::LM strips before constructing the
+        # adapter). `\b` after the version number allows dated suffixes
+        # (e.g. "claude-sonnet-5-20260315") while still rejecting unrelated
+        # models that merely share a numeric prefix (e.g. "claude-sonnet-50").
+        FAMILIES = [
+          [/\Aclaude-(fable|mythos)-5\b/, FABLE_MYTHOS_5],
+          [/\Aclaude-mythos-preview\b/, MYTHOS_PREVIEW],
+          [/\Aclaude-opus-4-[78]\b/, OPUS_4_7_OR_4_8],
+          [/\Aclaude-sonnet-5\b/, SONNET_5],
+          [/\Aclaude-(opus|sonnet)-4-6\b/, OPUS_OR_SONNET_4_6],
+          [/\Aclaude-opus-4-5\b/, OPUS_4_5]
+        ].freeze
+
+        def self.for(model)
+          _, capability = FAMILIES.find { |pattern, _| pattern.match?(model) }
+          capability || DEFAULT
+        end
+      end
+    end
+  end
+end

data/lib/dspy/anthropic/version.rb

@@ -2,6 +2,6 @@
 
 module DSPy
   module Anthropic
-    VERSION = '1.0.4'
+    VERSION = '1.0.6'
   end
 end

data/lib/dspy/anthropic.rb

@@ -3,7 +3,4 @@
 require 'dspy/anthropic/version'
 require 'dspy/anthropic/errors'
 
-require 'dspy/anthropic/guardrails'
-DSPy::Anthropic::Guardrails.ensure_anthropic_installed!
-
 require 'dspy/anthropic/lm/adapters/anthropic_adapter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dspy-anthropic
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.6
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
@@ -15,28 +15,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: 1.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: 1.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: anthropic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.28.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.28.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Provides the AnthropicAdapter so Claude-compatible providers can be added
   to DSPy.rb projects independently of the core gem.
 email:
@@ -49,8 +61,8 @@ files:
 - README.md
 - lib/dspy/anthropic.rb
 - lib/dspy/anthropic/errors.rb
-- lib/dspy/anthropic/guardrails.rb
 - lib/dspy/anthropic/lm/adapters/anthropic_adapter.rb
+- lib/dspy/anthropic/lm/model_capabilities.rb
 - lib/dspy/anthropic/lm/schema_converter.rb
 - lib/dspy/anthropic/version.rb
 homepage: https://github.com/vicentereig/dspy.rb

data/lib/dspy/anthropic/guardrails.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'dspy/lm/errors'
-
-module DSPy
-  module Anthropic
-    class Guardrails
-      SUPPORTED_ANTHROPIC_VERSIONS = "~> 1.12".freeze
-
-      def self.ensure_anthropic_installed!
-        require 'anthropic'
-
-        spec = Gem.loaded_specs["anthropic"]
-        unless spec && Gem::Requirement.new(SUPPORTED_ANTHROPIC_VERSIONS).satisfied_by?(spec.version)
-          msg = <<~MSG
-            DSPY requires the `anthropic` gem #{SUPPORTED_ANTHROPIC_VERSIONS}.
-            Please install or upgrade it with `bundle add anthropic --version "#{SUPPORTED_ANTHROPIC_VERSIONS}"`.
-          MSG
-          raise DSPy::LM::UnsupportedVersionError, msg
-        end
-      end
-    end
-  end
-end