dspy 0.27.2 → 0.27.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07ebaf2db9b6279275ac4dd61ac4f994ed5415561b0063310f006db084306092
-  data.tar.gz: 8e8c1cbfcb36d9ffa4bfd68f62317fba7d5d32a6b1409ce43749f555a719fc97
+  metadata.gz: d697eb8eb574ca5c23914c1911f1d7a03ad7411aa83b19bedf2231cacc544460
+  data.tar.gz: 3086cbaa86d01b0dd09512c9f5893f8a31b8d9988eed6782a967c24e1c12fb01
 SHA512:
-  metadata.gz: 8f19c7e01b5e03743457c9784b8cca05ef42e8002ff210dd59f08915f11ceb7c1c000f8b0eac6cd102c847f069194923a46c5197473ea53cda7616921ea1da26
-  data.tar.gz: 9ed8e5ec4e08eb83f17dbea912a7a14b28212968f36dc7adf6cad7dd7e62de8506e371e99bb4f8f1d785847b45783fdfada53dae3d1d039a4f8695aba54984b4
+  metadata.gz: eae9e4cba177e6cea359f1ffd55ebaa4203cc5a6594b86ab5fc2b9b9e8c54cf24838a8d18102ab96fc9a8f4b85827c3cb02ef0b75c3d077c6c70301abb52f48d
+  data.tar.gz: ecc26be5f85df66e911a71d5a1fa878cc42c79c7d63e42b2d1440836859814837f4ba782db18584161598867a5aef5ebbfef056a2988b4208767b8e0c1999013

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/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.3"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.27.2
+  version: 0.27.3
 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-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable