dspy 0.27.2 → 0.27.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07ebaf2db9b6279275ac4dd61ac4f994ed5415561b0063310f006db084306092
-  data.tar.gz: 8e8c1cbfcb36d9ffa4bfd68f62317fba7d5d32a6b1409ce43749f555a719fc97
+  metadata.gz: dca273acbd2ba8ab0ab9e2980bdf8048cc9ea80b3ce1b74d6f1e911e165ae895
+  data.tar.gz: '08177e7841275140c7f074ac3a700883f06c6610c9bfd4795d142a3c838c0b24'
 SHA512:
-  metadata.gz: 8f19c7e01b5e03743457c9784b8cca05ef42e8002ff210dd59f08915f11ceb7c1c000f8b0eac6cd102c847f069194923a46c5197473ea53cda7616921ea1da26
-  data.tar.gz: 9ed8e5ec4e08eb83f17dbea912a7a14b28212968f36dc7adf6cad7dd7e62de8506e371e99bb4f8f1d785847b45783fdfada53dae3d1d039a4f8695aba54984b4
+  metadata.gz: 1b8d4bd756ab303688366fb0bcb5e5a3e045152c5695a8cdcd5291ca6313fc8ee7bd8051c6026663cfda0ec429b7977aa2355442595ba803bfedafd3926e89b6
+  data.tar.gz: 30efa43a8bc34708003a178d7715ae6688268b4b63e98789f011e47f7d36b8c30f292ac986c8df3767bafa517b7b73f5ff7fa92fec8013732c69952dfa79df71

data/lib/dspy/lm/adapter_factory.rb

@@ -9,9 +9,12 @@ module DSPy
         'openai' => 'OpenAIAdapter',
         'anthropic' => 'AnthropicAdapter',
         'ollama' => 'OllamaAdapter',
-        'gemini' => 'GeminiAdapter'
+        'gemini' => 'GeminiAdapter',
+        'openrouter' => 'OpenrouterAdapter'
       }.freeze
 
+      PROVIDERS_WITH_EXTRA_OPTIONS = %w[openai ollama gemini openrouter].freeze
+
       class << self
         # Creates an adapter instance based on model_id
         # @param model_id [String] Full model identifier (e.g., "openai/gpt-4")
@@ -24,8 +27,8 @@ module DSPy
           
           # Pass provider-specific options
           adapter_options = { model: model, api_key: api_key }
-          # OpenAI, Ollama, and Gemini accept additional options
-          adapter_options.merge!(options) if %w[openai ollama gemini].include?(provider)
+          # Some providers accept additional options
+          adapter_options.merge!(options) if PROVIDERS_WITH_EXTRA_OPTIONS.include?(provider)
           
           adapter_class.new(**adapter_options)
         end

data/lib/dspy/lm/adapters/gemini/schema_converter.rb

@@ -11,24 +11,29 @@ module DSPy
           extend T::Sig
 
           # Models that support structured outputs (JSON + Schema)
-          # Based on official Google documentation and gemini-ai gem table
+          # Based on official Google documentation (Sept 2025)
           STRUCTURED_OUTPUT_MODELS = T.let([
-            "gemini-1.5-pro",              # ✅ Full schema support (legacy)
-            "gemini-1.5-pro-preview-0514", # ✅ Full schema support (legacy)
-            "gemini-1.5-pro-preview-0409", # ✅ Full schema support (legacy)
-            "gemini-2.5-flash",            # ✅ Full schema support (2025 current)
-            "gemini-2.5-flash-lite"        # ✅ Full schema support (2025 current)
+            # Gemini 1.5 series
+            "gemini-1.5-pro",
+            "gemini-1.5-pro-preview-0514",
+            "gemini-1.5-pro-preview-0409", 
+            "gemini-1.5-flash",             # ✅ Now supports structured outputs
+            "gemini-1.5-flash-8b",
+            # Gemini 2.0 series
+            "gemini-2.0-flash",
+            "gemini-2.0-flash-001",
+            # Gemini 2.5 series
+            "gemini-2.5-pro",
+            "gemini-2.5-flash", 
+            "gemini-2.5-flash-lite"
           ].freeze, T::Array[String])
 
-          # Models that support JSON mode but NOT schema
-          JSON_ONLY_MODELS = T.let([
-            "gemini-pro",                   # 🟡 JSON only, no schema
-            "gemini-1.5-flash",             # 🟡 JSON only, no schema (legacy)
-            "gemini-1.5-flash-preview-0514", # 🟡 JSON only, no schema (legacy)
-            "gemini-1.0-pro-002",           # 🟡 JSON only, no schema
-            "gemini-1.0-pro",               # 🟡 JSON only, no schema
-            "gemini-2.0-flash-001",         # 🟡 JSON only, no schema (2025)
-            "gemini-2.0-flash-lite-001"     # 🟡 JSON only, no schema (2025)
+          # Models that do not support structured outputs (legacy only)
+          UNSUPPORTED_MODELS = T.let([
+            # Legacy Gemini 1.0 series only
+            "gemini-pro",                   
+            "gemini-1.0-pro-002",
+            "gemini-1.0-pro"
           ].freeze, T::Array[String])
 
           sig { params(signature_class: T.class_of(DSPy::Signature)).returns(T::Hash[Symbol, T.untyped]) }

data/lib/dspy/lm/adapters/gemini_adapter.rb

@@ -14,11 +14,16 @@ module DSPy
         @structured_outputs_enabled = structured_outputs
         
         # Disable streaming for VCR tests since SSE responses don't record properly
+        # But keep streaming enabled for SSEVCR tests (SSE-specific cassettes)
         @use_streaming = true
         begin
-          @use_streaming = false if defined?(VCR) && VCR.current_cassette
+          vcr_active = defined?(VCR) && VCR.current_cassette
+          ssevcr_active = defined?(SSEVCR) && SSEVCR.turned_on?
+          
+          # Only disable streaming if regular VCR is active but SSEVCR is not
+          @use_streaming = false if vcr_active && !ssevcr_active
         rescue
-          # If VCR is not available or any error occurs, use streaming
+          # If VCR/SSEVCR is not available or any error occurs, use streaming
           @use_streaming = true
         end
 

data/lib/dspy/lm/adapters/openai_adapter.rb

@@ -29,10 +29,9 @@ module DSPy
           normalized_messages = handle_o1_messages(normalized_messages)
         end
 
-        request_params = {
-          model: model,
+        request_params = default_request_params.merge(
           messages: normalized_messages
-        }
+        )
 
         # Add temperature based on model capabilities  
         unless o1_model?(model)
@@ -123,6 +122,15 @@ module DSPy
         end
       end
 
+      protected
+
+      # Allow subclasses to override request params (add headers, etc)
+      def default_request_params
+        {
+          model: model
+        }
+      end
+
       private
 
       def supports_structured_outputs?

data/lib/dspy/lm/adapters/openrouter_adapter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'openai'
+
+module DSPy
+  class LM
+    class OpenrouterAdapter < OpenAIAdapter
+      BASE_URL = 'https://openrouter.ai/api/v1'
+
+      def initialize(model:, api_key: nil, structured_outputs: true, http_referrer: nil, x_title: nil)
+        # Don't call parent's initialize, do it manually to control client creation
+        @model = model
+        @api_key = api_key
+        @structured_outputs_enabled = structured_outputs
+
+        @http_referrer = http_referrer
+        @x_title = x_title
+
+        validate_configuration!
+
+        # Create client with custom base URL
+        @client = OpenAI::Client.new(
+          api_key: @api_key,
+          base_url: BASE_URL
+        )
+      end
+
+      def chat(messages:, signature: nil, response_format: nil, &block)
+        # For OpenRouter, we need to be more lenient with structured outputs
+        # as the model behind it may not fully support OpenAI's response_format spec
+        begin
+          super
+        rescue => e
+          # If structured output fails, retry with enhanced prompting
+          if @structured_outputs_enabled && signature && e.message.include?('response_format')
+            DSPy.logger.debug("OpenRouter structured output failed, falling back to enhanced prompting")
+            @structured_outputs_enabled = false
+            retry
+          else
+            raise
+          end
+        end
+      end
+
+      protected
+
+      # Add any OpenRouter-specific headers to all requests
+      def default_request_params
+        headers = {
+          'X-Title' => @x_title,
+          'HTTP-Referer' => @http_referrer
+        }.compact
+
+        upstream_params = super
+        upstream_params.merge!(request_options: { extra_headers: headers }) if headers.any?
+        upstream_params
+      end
+
+      private
+
+      def supports_structured_outputs?
+        # Different models behind OpenRouter may have different capabilities
+        # For now, we rely on whatever was passed to the constructor
+        @structured_outputs_enabled
+      end
+    end
+  end
+end

data/lib/dspy/lm.rb

@@ -17,6 +17,7 @@ require_relative 'lm/adapters/openai_adapter'
 require_relative 'lm/adapters/anthropic_adapter'
 require_relative 'lm/adapters/ollama_adapter'
 require_relative 'lm/adapters/gemini_adapter'
+require_relative 'lm/adapters/openrouter_adapter'
 
 # Load strategy system
 require_relative 'lm/strategy_selector'

data/lib/dspy/mixins/type_coercion.rb

@@ -37,11 +37,17 @@ module DSPy
         when ->(type) { hash_type?(type) }
           coerce_hash_value(value, prop_type)
         when ->(type) { enum_type?(type) }
-          extract_enum_class(prop_type).deserialize(value)
-        when Float, ->(type) { simple_type_match?(type, Float) }
+          coerce_enum_value(value, prop_type)
+        when ->(type) { type == Float || simple_type_match?(type, Float) }
           value.to_f
-        when Integer, ->(type) { simple_type_match?(type, Integer) }
+        when ->(type) { type == Integer || simple_type_match?(type, Integer) }
           value.to_i
+        when ->(type) { type == Date || simple_type_match?(type, Date) }
+          coerce_date_value(value)
+        when ->(type) { type == DateTime || simple_type_match?(type, DateTime) }
+          coerce_datetime_value(value)
+        when ->(type) { type == Time || simple_type_match?(type, Time) }
+          coerce_time_value(value)
         when ->(type) { struct_type?(type) }
           coerce_struct_value(value, prop_type)
         else
@@ -244,6 +250,63 @@ module DSPy
         DSPy.logger.debug("Failed to coerce union type: #{e.message}")
         value
       end
+
+      # Coerces a date value from string using ISO 8601 format
+      sig { params(value: T.untyped).returns(T.nilable(Date)) }
+      def coerce_date_value(value)
+        return value if value.is_a?(Date)
+        return nil if value.nil? || value.to_s.strip.empty?
+        
+        # Support ISO 8601 format (YYYY-MM-DD) like ActiveRecord
+        Date.parse(value.to_s)
+      rescue ArgumentError, TypeError
+        # Return nil for invalid dates rather than crashing
+        DSPy.logger.debug("Failed to coerce to Date: #{value}")
+        nil
+      end
+
+      # Coerces a datetime value from string using ISO 8601 format with timezone
+      sig { params(value: T.untyped).returns(T.nilable(DateTime)) }
+      def coerce_datetime_value(value)
+        return value if value.is_a?(DateTime)
+        return nil if value.nil? || value.to_s.strip.empty?
+        
+        # Parse ISO 8601 with timezone like ActiveRecord
+        # Formats: 2024-01-15T10:30:45Z, 2024-01-15T10:30:45+00:00, 2024-01-15 10:30:45
+        DateTime.parse(value.to_s)
+      rescue ArgumentError, TypeError
+        DSPy.logger.debug("Failed to coerce to DateTime: #{value}")
+        nil
+      end
+
+      # Coerces a time value from string, converting to UTC like ActiveRecord
+      sig { params(value: T.untyped).returns(T.nilable(Time)) }
+      def coerce_time_value(value)
+        return value if value.is_a?(Time)
+        return nil if value.nil? || value.to_s.strip.empty?
+        
+        # Parse and convert to UTC (like ActiveRecord with time_zone_aware_attributes)
+        # This ensures consistent timezone handling across the system
+        Time.parse(value.to_s).utc
+      rescue ArgumentError, TypeError
+        DSPy.logger.debug("Failed to coerce to Time: #{value}")
+        nil
+      end
+
+      # Coerces a value to an enum, handling both strings and existing enum instances
+      sig { params(value: T.untyped, prop_type: T.untyped).returns(T.untyped) }
+      def coerce_enum_value(value, prop_type)
+        enum_class = extract_enum_class(prop_type)
+        
+        # If value is already an instance of the enum class, return it as-is
+        return value if value.is_a?(enum_class)
+        
+        # Otherwise, try to deserialize from string
+        enum_class.deserialize(value.to_s)
+      rescue ArgumentError, KeyError => e
+        DSPy.logger.debug("Failed to coerce to enum #{enum_class}: #{e.message}")
+        value
+      end
     end
   end
 end

data/lib/dspy/observability/async_span_processor.rb

@@ -107,6 +107,7 @@ module DSPy
 
       def start_export_task
         return if @export_interval <= 0 # Disable timer for testing
+        return if ENV['DSPY_DISABLE_OBSERVABILITY'] == 'true' # Skip in tests
 
         # Start timer-based export task in background
         Thread.new do
@@ -129,6 +130,7 @@ module DSPy
 
       def trigger_export_if_batch_full
         return if @queue.size < @export_batch_size
+        return if ENV['DSPY_DISABLE_OBSERVABILITY'] == 'true' # Skip in tests
 
         # Trigger immediate export in background
         Thread.new do

data/lib/dspy/observability.rb

@@ -11,6 +11,12 @@ module DSPy
       def configure!
         @enabled = false
         
+        # Check for explicit disable flag first
+        if ENV['DSPY_DISABLE_OBSERVABILITY'] == 'true'
+          DSPy.log('observability.disabled', reason: 'Explicitly disabled via DSPY_DISABLE_OBSERVABILITY')
+          return
+        end
+        
         # Check for required Langfuse environment variables
         public_key = ENV['LANGFUSE_PUBLIC_KEY']
         secret_key = ENV['LANGFUSE_SECRET_KEY']
@@ -130,6 +136,17 @@ module DSPy
 
       def reset!
         @enabled = false
+        
+        # Shutdown OpenTelemetry if it's configured
+        if defined?(OpenTelemetry) && OpenTelemetry.tracer_provider
+          begin
+            OpenTelemetry.tracer_provider.shutdown(timeout: 1.0)
+          rescue => e
+            # Ignore shutdown errors in tests - log them but don't fail
+            DSPy.log('observability.shutdown_error', error: e.message) if respond_to?(:log)
+          end
+        end
+        
         @tracer = nil
         @endpoint = nil
       end

data/lib/dspy/predict.rb

@@ -137,11 +137,15 @@ module DSPy
     def forward_untyped(**input_values)
       # Module#forward handles span creation, we just do the prediction logic
       
-      # Store input values for optimization
-      @last_input_values = input_values.clone
+      # Apply type coercion to input values first
+      input_props = @signature_class.input_struct_class.props
+      coerced_input_values = coerce_output_attributes(input_values, input_props)
+      
+      # Store coerced input values for optimization
+      @last_input_values = coerced_input_values.clone
       
-      # Validate input
-      validate_input_struct(input_values)
+      # Validate input with coerced values
+      validate_input_struct(coerced_input_values)
       
       # Check if LM is configured
       current_lm = lm
@@ -149,19 +153,19 @@ module DSPy
         raise DSPy::ConfigurationError.missing_lm(self.class.name)
       end
       
-      # Call LM and process response
-      output_attributes = current_lm.chat(self, input_values)
+      # Call LM and process response with coerced input values
+      output_attributes = current_lm.chat(self, coerced_input_values)
       processed_output = process_lm_output(output_attributes)
       
-      # Create combined result struct
-      prediction_result = create_prediction_result(input_values, processed_output)
+      # Create combined result struct with coerced input values
+      prediction_result = create_prediction_result(coerced_input_values, processed_output)
       
       prediction_result
     end
 
     private
 
-    # Validates input using signature struct
+    # Validates input using signature struct (assumes input is already coerced)
     sig { params(input_values: T::Hash[Symbol, T.untyped]).void }
     def validate_input_struct(input_values)
       @signature_class.input_struct_class.new(**input_values)

data/lib/dspy/re_act.rb

@@ -66,6 +66,13 @@ module DSPy
     extend T::Sig
     include Mixins::StructBuilder
 
+    # AvailableTool struct for better type safety in ReAct agents
+    class AvailableTool < T::Struct
+      const :name, String
+      const :description, String
+      const :schema, T::Hash[Symbol, T.untyped]
+    end
+
     FINISH_ACTION = "finish"
     sig { returns(T.class_of(DSPy::Signature)) }
     attr_reader :original_signature_class
@@ -87,6 +94,9 @@ module DSPy
       tools.each { |tool| @tools[tool.name.downcase] = tool }
       @max_iterations = max_iterations
 
+      # Create dynamic ActionEnum class with tool names + finish
+      @action_enum_class = create_action_enum_class
+
       # Create dynamic signature classes that include the original input fields
       thought_signature = create_thought_signature(signature_class)
       observation_signature = create_observation_signature(signature_class)
@@ -143,9 +153,34 @@ module DSPy
 
     private
 
+    # Creates a dynamic ActionEnum class with tool names and "finish"
+    sig { returns(T.class_of(T::Enum)) }
+    def create_action_enum_class
+      tool_names = @tools.keys
+      all_actions = tool_names + [FINISH_ACTION]
+      
+      # Create a dynamic enum class using proper T::Enum pattern
+      enum_class = Class.new(T::Enum)
+      
+      # Build the enums block code dynamically
+      enum_definitions = all_actions.map do |action_name|
+        const_name = action_name.upcase.gsub(/[^A-Z0-9_]/, '_')
+        "#{const_name} = new(#{action_name.inspect})"
+      end.join("\n        ")
+      
+      enum_class.class_eval <<~RUBY
+        enums do
+          #{enum_definitions}
+        end
+      RUBY
+      
+      enum_class
+    end
+
     # Creates a dynamic Thought signature that includes the original input fields
     sig { params(signature_class: T.class_of(DSPy::Signature)).returns(T.class_of(DSPy::Signature)) }
     def create_thought_signature(signature_class)
+      action_enum_class = @action_enum_class
       # Create new class that inherits from DSPy::Signature
       Class.new(DSPy::Signature) do
         # Set description
@@ -154,21 +189,21 @@ module DSPy
         # Define input fields
         input do
           const :input_context, String,
-            desc: "Serialized representation of all input fields"
+            description: "Serialized representation of all input fields"
           const :history, T::Array[HistoryEntry],
-            desc: "Previous thoughts and actions, including observations from tools."
-          const :available_tools, T::Array[T::Hash[String, T.untyped]],
-            desc: "Array of available tools with their JSON schemas."
+            description: "Previous thoughts and actions, including observations from tools."
+          const :available_tools, T::Array[AvailableTool],
+            description: "Array of available tools with their JSON schemas."
         end
 
         # Define output fields (same as ThoughtBase)
         output do
           const :thought, String,
-            desc: "Reasoning about what to do next, considering the history and observations."
-          const :action, String,
-            desc: "The action to take. MUST be one of the tool names listed in `available_tools` input, or the literal string \"finish\" to provide the final answer."
+            description: "Reasoning about what to do next, considering the history and observations."
+          const :action, action_enum_class,
+            description: "The action to take. MUST be one of the tool names listed in `available_tools` input, or the literal string \"finish\" to provide the final answer."
           const :action_input, T.any(String, T::Hash[T.untyped, T.untyped]),
-            desc: "Input for the chosen action. If action is a tool name, this MUST be a JSON object matching the tool's schema. If action is \"finish\", this field MUST contain the final result based on processing the input data."
+            description: "Input for the chosen action. If action is a tool name, this MUST be a JSON object matching the tool's schema. If action is \"finish\", this field MUST contain the final result based on processing the input data."
         end
       end
     end
@@ -184,19 +219,19 @@ module DSPy
         # Define input fields
         input do
           const :input_context, String,
-            desc: "Serialized representation of all input fields"
+            description: "Serialized representation of all input fields"
           const :history, T::Array[HistoryEntry],
-            desc: "Previous thoughts, actions, and observations."
+            description: "Previous thoughts, actions, and observations."
           const :observation, String,
-            desc: "The result from the last action"
+            description: "The result from the last action"
         end
 
         # Define output fields (same as ReActObservationBase)
         output do
           const :interpretation, String,
-            desc: "Interpretation of the observation"
+            description: "Interpretation of the observation"
           const :next_step, NextStep,
-            desc: "What to do next: '#{NextStep::Continue}' or '#{NextStep::Finish}'"
+            description: "What to do next: '#{NextStep::Continue}' or '#{NextStep::Finish}'"
         end
       end
     end
@@ -205,7 +240,14 @@ module DSPy
     sig { params(input_struct: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
     def execute_react_reasoning_loop(input_struct)
       history = T.let([], T::Array[HistoryEntry])
-      available_tools_desc = @tools.map { |name, tool| JSON.parse(tool.schema) }
+      available_tools_desc = @tools.map { |name, tool| 
+        schema = JSON.parse(tool.schema)
+        AvailableTool.new(
+          name: name,
+          description: tool.description,
+          schema: schema.transform_keys(&:to_sym)
+        )
+      }
       final_answer = T.let(nil, T.nilable(String))
       iterations_count = 0
       last_observation = T.let(nil, T.nilable(String))
@@ -239,7 +281,7 @@ module DSPy
     end
 
     # Executes a single iteration of the ReAct loop
-    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[T::Hash[String, T.untyped]], iteration: Integer, tools_used: T::Array[String], last_observation: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[AvailableTool], iteration: Integer, tools_used: T::Array[String], last_observation: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
     def execute_single_iteration(input_struct, history, available_tools_desc, iteration, tools_used, last_observation)
       # Track each iteration with agent span
       DSPy::Context.with_span(
@@ -272,12 +314,15 @@ module DSPy
           thought_obj.action, thought_obj.action_input, iteration
         )
 
+        # Convert action enum to string for processing and storage
+        action_str = thought_obj.action.respond_to?(:serialize) ? thought_obj.action.serialize : thought_obj.action.to_s
+        
         # Track tools used
-        tools_used << thought_obj.action.downcase if valid_tool?(thought_obj.action)
+        tools_used << action_str.downcase if valid_tool?(thought_obj.action)
 
         # Add to history
         history << create_history_entry(
-          iteration, thought_obj.thought, thought_obj.action,
+          iteration, thought_obj.thought, action_str,
           thought_obj.action_input, observation
         )
 
@@ -291,7 +336,7 @@ module DSPy
         end
 
         emit_iteration_complete_event(
-          iteration, thought_obj.thought, thought_obj.action,
+          iteration, thought_obj.thought, action_str,
           thought_obj.action_input, observation, tools_used
         )
 
@@ -341,31 +386,39 @@ module DSPy
       final_answer.nil? && (@max_iterations.nil? || iterations_count < @max_iterations)
     end
 
-    sig { params(action: T.nilable(String)).returns(T::Boolean) }
+    sig { params(action: T.nilable(T.any(String, T::Enum))).returns(T::Boolean) }
     def finish_action?(action)
-      action&.downcase == FINISH_ACTION
+      return false unless action
+      action_str = action.respond_to?(:serialize) ? action.serialize : action.to_s
+      action_str.downcase == FINISH_ACTION
     end
 
-    sig { params(action: T.nilable(String)).returns(T::Boolean) }
+    sig { params(action: T.nilable(T.any(String, T::Enum))).returns(T::Boolean) }
     def valid_tool?(action)
-      !!(action && @tools[action.downcase])
+      return false unless action
+      action_str = action.respond_to?(:serialize) ? action.serialize : action.to_s
+      !!@tools[action_str.downcase]
     end
 
-    sig { params(action: T.nilable(String), action_input: T.untyped, iteration: Integer).returns(String) }
+    sig { params(action: T.nilable(T.any(String, T::Enum)), action_input: T.untyped, iteration: Integer).returns(String) }
     def execute_tool_with_instrumentation(action, action_input, iteration)
-      if action && @tools[action.downcase]
+      return "Unknown action: #{action}. Available actions: #{@tools.keys.join(', ')}, finish" unless action
+      
+      action_str = action.respond_to?(:serialize) ? action.serialize : action.to_s
+      
+      if @tools[action_str.downcase]
         DSPy::Context.with_span(
           operation: 'react.tool_call',
           **DSPy::ObservationType::Tool.langfuse_attributes,
           'dspy.module' => 'ReAct',
           'react.iteration' => iteration,
-          'tool.name' => action.downcase,
+          'tool.name' => action_str.downcase,
           'tool.input' => action_input
         ) do
-          execute_action(action, action_input)
+          execute_action(action_str, action_input)
         end
       else
-        "Unknown action: #{action}. Available actions: #{@tools.keys.join(', ')}, finish"
+        "Unknown action: #{action_str}. Available actions: #{@tools.keys.join(', ')}, finish"
       end
     end
 
@@ -380,7 +433,7 @@ module DSPy
       )
     end
 
-    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], observation: String, available_tools_desc: T::Array[T::Hash[String, T.untyped]], iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], observation: String, available_tools_desc: T::Array[AvailableTool], iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
     def process_observation_and_decide_next_step(input_struct, history, observation, available_tools_desc, iteration)
       return { should_finish: false } if observation.include?("Unknown action")
 
@@ -399,7 +452,7 @@ module DSPy
       { should_finish: true, final_answer: final_answer }
     end
 
-    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[T::Hash[String, T.untyped]], observation_result: T.untyped, iteration: Integer).returns(String) }
+    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[AvailableTool], observation_result: T.untyped, iteration: Integer).returns(String) }
     def generate_forced_final_answer(input_struct, history, available_tools_desc, observation_result, iteration)
       final_thought = @thought_generator.forward(
         input_context: DSPy::TypeSerializer.serialize(input_struct).to_json,
@@ -407,7 +460,8 @@ module DSPy
         available_tools: available_tools_desc
       )
 
-      if final_thought.action&.downcase != FINISH_ACTION
+      action_str = final_thought.action.respond_to?(:serialize) ? final_thought.action.serialize : final_thought.action.to_s
+      if action_str.downcase != FINISH_ACTION
         forced_answer = if observation_result.interpretation && !observation_result.interpretation.empty?
                           observation_result.interpretation
                         else
@@ -516,7 +570,7 @@ module DSPy
       example
     end
 
-    sig { params(action_input: T.untyped, last_observation: T.nilable(String), step: Integer, thought: String, action: String, history: T::Array[HistoryEntry]).returns(String) }
+    sig { params(action_input: T.untyped, last_observation: T.nilable(String), step: Integer, thought: String, action: T.any(String, T::Enum), history: T::Array[HistoryEntry]).returns(String) }
     def handle_finish_action(action_input, last_observation, step, thought, action, history)
       final_answer = action_input.to_s
 
@@ -525,11 +579,14 @@ module DSPy
         final_answer = last_observation
       end
 
+      # Convert action enum to string for storage in history
+      action_str = action.respond_to?(:serialize) ? action.serialize : action.to_s
+
       # Always add the finish action to history
       history << HistoryEntry.new(
         step: step,
         thought: thought,
-        action: action,
+        action: action_str,
         action_input: final_answer,
         observation: nil  # No observation for finish action
       )

data/lib/dspy/signature.rb

@@ -207,6 +207,12 @@ module DSPy
             { type: "number" }
           elsif type == Numeric
             { type: "number" }
+          elsif type == Date
+            { type: "string", format: "date" }
+          elsif type == DateTime
+            { type: "string", format: "date-time" }
+          elsif type == Time
+            { type: "string", format: "date-time" }
           elsif [TrueClass, FalseClass].include?(type)
             { type: "boolean" }
           elsif type < T::Struct
@@ -225,6 +231,12 @@ module DSPy
             { type: "number" }
           when "Numeric"
             { type: "number" }
+          when "Date"
+            { type: "string", format: "date" }
+          when "DateTime"
+            { type: "string", format: "date-time" }
+          when "Time"
+            { type: "string", format: "date-time" }
           when "TrueClass", "FalseClass"
             { type: "boolean" }
           when "T::Boolean"

data/lib/dspy/tools/github_cli_toolset.rb

@@ -61,14 +61,10 @@ module DSPy
       toolset_name "github"
 
       # Expose methods as tools with descriptions
-      tool :create_issue, description: "Create a new GitHub issue"
-      tool :create_pr, description: "Create a new GitHub pull request"
       tool :list_issues, description: "List GitHub issues with optional filters"
       tool :list_prs, description: "List GitHub pull requests with optional filters"
       tool :get_issue, description: "Get details of a specific GitHub issue"
       tool :get_pr, description: "Get details of a specific GitHub pull request"
-      tool :comment_on_issue, description: "Add a comment to a GitHub issue"
-      tool :review_pr, description: "Add a review to a GitHub pull request"
       tool :api_request, description: "Make an arbitrary GitHub API request"
 
       sig { void }
@@ -76,64 +72,7 @@ module DSPy
         # No persistent state needed
       end
 
-      sig { params(
-        title: String,
-        body: String,
-        labels: T::Array[String],
-        assignees: T::Array[String],
-        repo: T.nilable(String)
-      ).returns(String) }
-      def create_issue(title:, body:, labels: [], assignees: [], repo: nil)
-        cmd = build_gh_command(['issue', 'create'])
-        cmd << ['--title', shell_escape(title)]
-        cmd << ['--body', shell_escape(body)]
-        
-        labels.each { |label| cmd << ['--label', shell_escape(label)] }
-        assignees.each { |assignee| cmd << ['--assignee', shell_escape(assignee)] }
-        
-        if repo
-          cmd << ['--repo', shell_escape(repo)]
-        end
-
-        result = execute_command(cmd.flatten.join(' '))
-        
-        if result[:success]
-          "Issue created successfully: #{result[:output].strip}"
-        else
-          "Failed to create issue: #{result[:error]}"
-        end
-      rescue => e
-        "Error creating issue: #{e.message}"
-      end
 
-      sig { params(
-        title: String,
-        body: String,
-        base: String,
-        head: String,
-        repo: T.nilable(String)
-      ).returns(String) }
-      def create_pr(title:, body:, base:, head:, repo: nil)
-        cmd = build_gh_command(['pr', 'create'])
-        cmd << ['--title', shell_escape(title)]
-        cmd << ['--body', shell_escape(body)]
-        cmd << ['--base', shell_escape(base)]
-        cmd << ['--head', shell_escape(head)]
-        
-        if repo
-          cmd << ['--repo', shell_escape(repo)]
-        end
-
-        result = execute_command(cmd.flatten.join(' '))
-        
-        if result[:success]
-          "Pull request created successfully: #{result[:output].strip}"
-        else
-          "Failed to create pull request: #{result[:error]}"
-        end
-      rescue => e
-        "Error creating pull request: #{e.message}"
-      end
 
       sig { params(
         state: IssueState,
@@ -241,58 +180,7 @@ module DSPy
         "Error getting pull request: #{e.message}"
       end
 
-      sig { params(
-        issue_number: Integer,
-        comment: String,
-        repo: T.nilable(String)
-      ).returns(String) }
-      def comment_on_issue(issue_number:, comment:, repo: nil)
-        cmd = build_gh_command(['issue', 'comment', issue_number.to_s])
-        cmd << ['--body', shell_escape(comment)]
-        
-        if repo
-          cmd << ['--repo', shell_escape(repo)]
-        end
 
-        result = execute_command(cmd.flatten.join(' '))
-        
-        if result[:success]
-          "Comment added successfully to issue ##{issue_number}"
-        else
-          "Failed to add comment: #{result[:error]}"
-        end
-      rescue => e
-        "Error adding comment: #{e.message}"
-      end
-
-      sig { params(
-        pr_number: Integer,
-        review_type: ReviewState,
-        comment: T.nilable(String),
-        repo: T.nilable(String)
-      ).returns(String) }
-      def review_pr(pr_number:, review_type:, comment: nil, repo: nil)
-        cmd = build_gh_command(['pr', 'review', pr_number.to_s])
-        cmd << ['--' + review_type.serialize.tr('_', '-')]
-        
-        if comment
-          cmd << ['--body', shell_escape(comment)]
-        end
-        
-        if repo
-          cmd << ['--repo', shell_escape(repo)]
-        end
-
-        result = execute_command(cmd.flatten.join(' '))
-        
-        if result[:success]
-          "Review added successfully to PR ##{pr_number}"
-        else
-          "Failed to add review: #{result[:error]}"
-        end
-      rescue => e
-        "Error adding review: #{e.message}"
-      end
 
       sig { params(
         endpoint: String,
@@ -301,6 +189,11 @@ module DSPy
         repo: T.nilable(String)
       ).returns(String) }
       def api_request(endpoint:, method: 'GET', fields: {}, repo: nil)
+        # Restrict to read-only operations
+        unless method.upcase == 'GET'
+          return "Error: Only GET requests are allowed for read-only access"
+        end
+        
         cmd = build_gh_command(['api', endpoint])
         cmd << ['--method', method.upcase]
         

data/lib/dspy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DSPy
-  VERSION = "0.27.2"
+  VERSION = "0.27.4"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.27.2
+  version: 0.27.4
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-09-16 00:00:00.000000000 Z
+date: 2025-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -212,6 +212,7 @@ files:
 - lib/dspy/lm/adapters/ollama_adapter.rb
 - lib/dspy/lm/adapters/openai/schema_converter.rb
 - lib/dspy/lm/adapters/openai_adapter.rb
+- lib/dspy/lm/adapters/openrouter_adapter.rb
 - lib/dspy/lm/errors.rb
 - lib/dspy/lm/message.rb
 - lib/dspy/lm/message_builder.rb