dspy 0.34.1 → 0.34.3

data/lib/dspy/prompt.rb

@@ -26,24 +26,14 @@ module DSPy
     sig { returns(T.nilable(String)) }
     attr_reader :signature_class_name
 
-    # Returns the effective schema format
-    # Precedence: instance variable (if not :json default) > config.lm > :json
     sig { returns(Symbol) }
     def schema_format
-      # If @schema_format was explicitly set to something other than :json, respect it
-      return @schema_format if @schema_format && @schema_format != :json
-
-      # Otherwise, read from config if available
-      DSPy.config.lm&.schema_format || @schema_format || :json
+      @schema_format || :json
     end
 
     sig { returns(Symbol) }
     def data_format
-      return @data_format if @data_format && @data_format != :json
-
-      lm = DSPy.config.lm
-      lm_format = lm&.respond_to?(:data_format) ? lm.data_format : nil
-      lm_format || @data_format || :json
+      @data_format || :json
     end
 
     sig { returns(T.nilable(T.class_of(Signature))) }
@@ -56,20 +46,20 @@ module DSPy
         output_schema: T::Hash[Symbol, T.untyped],
         few_shot_examples: T::Array[FewShotExample],
         signature_class_name: T.nilable(String),
-        schema_format: Symbol,
+        schema_format: T.nilable(Symbol),
         signature_class: T.nilable(T.class_of(Signature)),
-        data_format: Symbol
+        data_format: T.nilable(Symbol)
       ).void
     end
-    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: :json, signature_class: nil, data_format: :json)
+    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: nil, signature_class: nil, data_format: nil)
       @instruction = instruction
       @few_shot_examples = few_shot_examples.freeze
       @input_schema = input_schema.freeze
       @output_schema = output_schema.freeze
       @signature_class_name = signature_class_name
-      @schema_format = schema_format
+      @schema_format = resolve_schema_format(schema_format)
       @signature_class = signature_class
-      @data_format = data_format
+      @data_format = resolve_data_format(data_format)
     end
 
     # Immutable update methods for optimization
@@ -107,6 +97,34 @@ module DSPy
       with_examples(combined_examples)
     end
 
+    sig { params(new_schema_format: Symbol).returns(Prompt) }
+    def with_schema_format(new_schema_format)
+      self.class.new(
+        instruction: @instruction,
+        input_schema: @input_schema,
+        output_schema: @output_schema,
+        few_shot_examples: @few_shot_examples,
+        signature_class_name: @signature_class_name,
+        schema_format: new_schema_format,
+        signature_class: @signature_class,
+        data_format: @data_format
+      )
+    end
+
+    sig { params(new_data_format: Symbol).returns(Prompt) }
+    def with_data_format(new_data_format)
+      self.class.new(
+        instruction: @instruction,
+        input_schema: @input_schema,
+        output_schema: @output_schema,
+        few_shot_examples: @few_shot_examples,
+        signature_class_name: @signature_class_name,
+        schema_format: @schema_format,
+        signature_class: @signature_class,
+        data_format: new_data_format
+      )
+    end
+
     # Core prompt rendering methods
     sig { returns(String) }
     def render_system_prompt
@@ -233,15 +251,6 @@ module DSPy
       sections.join("\n")
     end
 
-    # Generate messages for LM adapter
-    sig { params(input_values: T::Hash[Symbol, T.untyped]).returns(T::Array[T::Hash[Symbol, String]]) }
-    def to_messages(input_values)
-      [
-        { role: 'system', content: render_system_prompt },
-        { role: 'user', content: render_user_prompt(input_values) }
-      ]
-    end
-
     # Serialization for persistence and optimization
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
@@ -280,10 +289,6 @@ module DSPy
       ).returns(Prompt)
     end
     def self.from_signature(signature_class, schema_format: nil, data_format: nil)
-      lm = DSPy.config.lm
-      schema_format ||= lm&.schema_format || :json
-      data_format ||= (lm&.respond_to?(:data_format) ? lm.data_format : nil) || :json
-
       new(
         instruction: signature_class.description || "Complete this task.",
         input_schema: signature_class.input_json_schema,
@@ -506,5 +511,20 @@ module DSPy
       base = 'value' if base.empty?
       "example_#{base}"
     end
+
+    def resolve_schema_format(schema_format)
+      return schema_format unless schema_format.nil?
+
+      lm = DSPy.respond_to?(:current_lm) ? DSPy.current_lm : DSPy.config.lm
+      lm&.schema_format || :json
+    end
+
+    def resolve_data_format(data_format)
+      return data_format unless data_format.nil?
+
+      lm = DSPy.respond_to?(:current_lm) ? DSPy.current_lm : DSPy.config.lm
+      lm_format = lm&.respond_to?(:data_format) ? lm.data_format : nil
+      lm_format || :json
+    end
   end
 end

data/lib/dspy/propose/dataset_summary_generator.rb

@@ -157,7 +157,7 @@ module DSPy
 
               observations += output.observations
             end
-          rescue => e
+          rescue StandardError => e
             if verbose
               puts "Error during observation refinement: #{e.message}. Using observations from past round for summary."
             end

data/lib/dspy/propose/grounded_proposer.rb

@@ -160,7 +160,7 @@ module DSPy
               DSPy.current_lm,
               verbose: @config.verbose
             )
-          rescue => e
+          rescue StandardError => e
             DSPy.logger.warn("Failed to generate dataset summary: #{e.message}")
             @dataset_summary = nil
           end
@@ -189,7 +189,7 @@ module DSPy
         # This is a simplified version - could be enhanced with method_source gem
         code = "Program: #{klass.name}\nSource: #{file}:#{line}"
         code
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.warn("Could not extract program source: #{e.message}")
         nil
       end
@@ -506,7 +506,7 @@ module DSPy
             instruction = result.instruction.strip
 
             candidates << instruction if instruction.length > 0
-          rescue => error
+          rescue StandardError => error
             DSPy.logger.warn("Failed to generate instruction candidate #{i + 1}: #{error.message}")
           end
         end

data/lib/dspy/re_act.rb

@@ -33,21 +33,6 @@ module DSPy
       }
     end
   end
-  # Base class for ReAct thought generation - will be customized per input type
-  class ThoughtBase < DSPy::Signature
-    description "Generate a thought about what to do next to process the given inputs."
-
-    output do
-      const :thought, String,
-        description: "Reasoning about what to do next, considering the history and observations."
-      const :action, String,
-        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 :tool_input, ToolInput,
-        description: "Input for the chosen tool action. Required when action is a tool name. MUST be a JSON object matching the tool's parameter schema. Set to null when action is \"finish\"."
-      const :final_answer, T.nilable(String),
-        description: "The final answer to return. Required when action is \"finish\". Must match the expected output type. Set to null when action is a tool name."
-    end
-  end
 
   class NextStep < T::Enum
     enums do
@@ -56,18 +41,6 @@ module DSPy
     end
   end
 
-  # Base class for observation processing - will be customized per input type
-  class ReActObservationBase < DSPy::Signature
-    description "Process the observation from a tool and decide what to do next."
-
-    output do
-      const :interpretation, String,
-        description: "Interpretation of the observation"
-      const :next_step, NextStep,
-        description: "What to do next: '#{NextStep::Continue}' or '#{NextStep::Finish}'"
-    end
-  end
-
   # ReAct Agent using Sorbet signatures
   class ReAct < Predict
     extend T::Sig
@@ -731,113 +704,6 @@ module DSPy
       end
     end
 
-    # Checks if a type is a scalar (primitives that don't need special serialization)
-    sig { params(type_object: T.untyped).returns(T::Boolean) }
-    def scalar_type?(type_object)
-      case type_object
-      when T::Types::Simple
-        scalar_classes = [String, Integer, Float, Numeric, TrueClass, FalseClass]
-        scalar_classes.any? { |klass| type_object.raw_type == klass || type_object.raw_type <= klass }
-      when T::Types::Union
-        # Union is scalar if all its types are scalars
-        type_object.types.all? { |t| scalar_type?(t) }
-      else
-        false
-      end
-    end
-
-    # Checks if a type is structured (arrays, hashes, structs that need type preservation)
-    sig { params(type_object: T.untyped).returns(T::Boolean) }
-    def structured_type?(type_object)
-      return true if type_object.is_a?(T::Types::TypedArray)
-      return true if type_object.is_a?(T::Types::TypedHash)
-
-      if type_object.is_a?(T::Types::Simple)
-        raw_type = type_object.raw_type
-        return true if raw_type.respond_to?(:<=) && raw_type <= T::Struct
-      end
-
-      # For union types (like T.nilable(T::Array[...])), check if any non-nil type is structured
-      if type_object.is_a?(T::Types::Union)
-        non_nil_types = type_object.types.reject { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
-        return non_nil_types.any? { |t| structured_type?(t) }
-      end
-
-      false
-    end
-
-    # Checks if a type is String or compatible with String (e.g., T.any(String, ...) or T.nilable(String))
-    sig { params(type_object: T.untyped).returns(T::Boolean) }
-    def string_type?(type_object)
-      case type_object
-      when T::Types::Simple
-        type_object.raw_type == String
-      when T::Types::Union
-        # Check if any of the union types is String
-        type_object.types.any? { |t| t.is_a?(T::Types::Simple) && t.raw_type == String }
-      else
-        false
-      end
-    end
-
-    # Alias for backward compatibility
-    alias string_compatible_type? string_type?
-
-    # Get a readable type name from a Sorbet type object
-    sig { params(type_object: T.untyped).returns(String) }
-    def type_name(type_object)
-      case type_object
-      when T::Types::TypedArray
-        element_type = type_object.type
-        "T::Array[#{type_name(element_type)}]"
-      when T::Types::TypedHash
-        "T::Hash"
-      when T::Types::Simple
-        type_object.raw_type.to_s
-      when T::Types::Union
-        types_str = type_object.types.map { |t| type_name(t) }.join(', ')
-        "T.any(#{types_str})"
-      else
-        type_object.to_s
-      end
-    end
-
-    # Returns an appropriate default value for a given Sorbet type
-    # This is used when max iterations is reached without a successful completion
-    sig { params(type_object: T.untyped).returns(T.untyped) }
-    def default_value_for_type(type_object)
-      # Handle TypedArray (T::Array[...])
-      if type_object.is_a?(T::Types::TypedArray)
-        return []
-      end
-
-      # Handle TypedHash (T::Hash[...])
-      if type_object.is_a?(T::Types::TypedHash)
-        return {}
-      end
-
-      # Handle simple types
-      case type_object
-      when T::Types::Simple
-        raw_type = type_object.raw_type
-        case raw_type.to_s
-        when 'String' then ''
-        when 'Integer' then 0
-        when 'Float' then 0.0
-        when 'TrueClass', 'FalseClass' then false
-        else
-          # For T::Struct types, return nil as fallback
-          nil
-        end
-      when T::Types::Union
-        # For unions, return nil (assuming it's nilable) or first non-nil default
-        nil
-      else
-        # Default fallback for unknown types
-        nil
-      end
-    end
-
     # Tool execution method
     sig { params(action: String, tool_input: ToolInput).returns(T.untyped) }
     def execute_action(action, tool_input)
@@ -855,34 +721,6 @@ module DSPy
       end
     end
 
-    sig { params(output: T.untyped).void }
-    def validate_output_schema!(output)
-      # Validate that output is an instance of the enhanced output struct
-      unless output.is_a?(@enhanced_output_struct)
-        raise "Output must be an instance of #{@enhanced_output_struct}, got #{output.class}"
-      end
-
-      # Validate original signature output fields are present
-      @original_signature_class.output_struct_class.props.each do |field_name, _prop|
-        unless output.respond_to?(field_name)
-          raise "Missing required field: #{field_name}"
-        end
-      end
-
-      # Validate ReAct-specific fields
-      unless output.respond_to?(:history) && output.history.is_a?(Array)
-        raise "Missing or invalid history field"
-      end
-
-      unless output.respond_to?(:iterations) && output.iterations.is_a?(Integer)
-        raise "Missing or invalid iterations field"
-      end
-
-      unless output.respond_to?(:tools_used) && output.tools_used.is_a?(Array)
-        raise "Missing or invalid tools_used field"
-      end
-    end
-
     sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def generate_example_output
       example = super

data/lib/dspy/registry/signature_registry.rb

@@ -259,7 +259,7 @@ module DSPy
           emit_register_complete_event(signature_version)
           signature_version
 
-        rescue => error
+        rescue StandardError => error
           emit_register_error_event(signature_name, version, error)
           raise
         end
@@ -313,7 +313,7 @@ module DSPy
           emit_deploy_complete_event(deployed_version)
           deployed_version
 
-        rescue => error
+        rescue StandardError => error
           emit_deploy_error_event(signature_name, version, error)
           nil
         end
@@ -363,7 +363,7 @@ module DSPy
           emit_rollback_error_event(signature_name, "No previous version to rollback to")
           nil
 
-        rescue => error
+        rescue StandardError => error
           emit_rollback_error_event(signature_name, error.message)
           nil
         end

data/lib/dspy/ruby_llm/lm/adapters/ruby_llm_adapter.rb

@@ -52,7 +52,7 @@ module DSPy
             # Validate vision support if images are present
             if contains_images?(normalized_messages)
               validate_vision_support!
-              normalized_messages = format_multimodal_messages(normalized_messages)
+              normalized_messages = format_multimodal_messages(normalized_messages, provider)
             end
 
             chat_instance = create_chat_instance
@@ -358,32 +358,6 @@ module DSPy
             # If DSPy doesn't know about the model, let RubyLLM handle it
             # RubyLLM has its own model registry with capability detection
           end
-
-          def format_multimodal_messages(messages)
-            messages.map do |msg|
-              if msg[:content].is_a?(Array)
-                formatted_content = msg[:content].map do |item|
-                  case item[:type]
-                  when 'text'
-                    { type: 'text', text: item[:text] }
-                  when 'image'
-                    # Validate and format image for provider
-                    image = item[:image]
-                    if image.respond_to?(:validate_for_provider!)
-                      image.validate_for_provider!(provider)
-                    end
-                    item
-                  else
-                    item
-                  end
-                end
-
-                { role: msg[:role], content: formatted_content }
-              else
-                msg
-              end
-            end
-          end
         end
       end
     end

data/lib/dspy/schema/sorbet_json_schema.rb

@@ -195,10 +195,10 @@ module DSPy
             end
           else
             # Not nilable SimplePairUnion - this is a regular T.any() union
-            # Generate oneOf schema for all types
+            # Generate anyOf schema for all types (oneOf not supported by Anthropic strict mode)
             if type.respond_to?(:types) && type.types.length > 1
               {
-                oneOf: type.types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
+                anyOf: type.types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
                 description: "Union of multiple types"
               }
             else
@@ -237,14 +237,14 @@ module DSPy
             # Non-nilable single type union (shouldn't happen in practice)
             type_to_json_schema_internal(non_nil_types.first, visited, definitions)
           elsif non_nil_types.size > 1
-            # Handle complex unions with oneOf for better JSON schema compliance
+            # Handle complex unions with anyOf (oneOf not supported by Anthropic strict mode)
             base_schema = {
-              oneOf: non_nil_types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
+              anyOf: non_nil_types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
               description: "Union of multiple types"
             }
             if is_nilable
               # Add null as an option for complex nilable unions
-              base_schema[:oneOf] << { type: "null" }
+              base_schema[:anyOf] << { type: "null" }
             end
             base_schema
           else
@@ -335,7 +335,8 @@ module DSPy
           type: "object",
           properties: properties,
           required: required,
-          description: "#{struct_name} struct"
+          description: "#{struct_name} struct",
+          additionalProperties: false
         }
 
         # Add this struct's schema to definitions for $defs

data/lib/dspy/schema/version.rb

@@ -2,6 +2,6 @@
 
 module DSPy
   module Schema
-    VERSION = "1.0.0"
+    VERSION = "1.0.2"
   end
 end

data/lib/dspy/schema_adapters.rb

@@ -46,7 +46,7 @@ module DSPy
         begin
           result = from_hash(struct_class, hash_data)
           [true, result]
-        rescue => e
+        rescue StandardError => e
           [false, [e.message]]
         end
       end

data/lib/dspy/storage/program_storage.rb

@@ -198,7 +198,7 @@ module DSPy
           emit_save_complete_event(saved_program)
           saved_program
           
-        rescue => error
+        rescue StandardError => error
           emit_save_error_event(program_id, error)
           raise
         end
@@ -223,7 +223,7 @@ module DSPy
           emit_load_complete_event(saved_program)
           saved_program
           
-        rescue => error
+        rescue StandardError => error
           emit_load_error_event(program_id, error)
           nil
         end

data/lib/dspy/structured_outputs_prompt.rb

@@ -16,12 +16,12 @@ module DSPy
         output_schema: T::Hash[Symbol, T.untyped],
         few_shot_examples: T::Array[T.untyped],
         signature_class_name: T.nilable(String),
-        schema_format: Symbol,
+        schema_format: T.nilable(Symbol),
         signature_class: T.nilable(T.class_of(Signature)),
-        data_format: Symbol
+        data_format: T.nilable(Symbol)
       ).void
     end
-    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: :json, signature_class: nil, data_format: :json)
+    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: nil, signature_class: nil, data_format: nil)
       normalized_examples = few_shot_examples.map do |example|
         case example
         when FewShotExample

data/lib/dspy/teleprompt/utils.rb

@@ -360,7 +360,7 @@ module DSPy
               )
               successful_demos << demo
             end
-          rescue => e
+          rescue StandardError => e
             # Continue on errors
             DSPy.logger.warn("Bootstrap error: #{e.message}") if DSPy.logger
           end
@@ -513,7 +513,7 @@ module DSPy
               emit_bootstrap_example_event(index, false, "Prediction did not match expected output")
             end
 
-          rescue => error
+          rescue StandardError => error
             error_count += 1
             failed << example
             emit_bootstrap_example_event(index, false, error.message)

data/lib/dspy/tools/github_cli_toolset.rb

@@ -105,7 +105,7 @@ module DSPy
         else
           "Failed to list issues: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error listing issues: #{e.message}"
       end
 
@@ -140,7 +140,7 @@ module DSPy
         else
           "Failed to list pull requests: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error listing pull requests: #{e.message}"
       end
 
@@ -159,7 +159,7 @@ module DSPy
         else
           "Failed to get issue: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error getting issue: #{e.message}"
       end
 
@@ -178,7 +178,7 @@ module DSPy
         else
           "Failed to get pull request: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error getting pull request: #{e.message}"
       end
 
@@ -214,7 +214,7 @@ module DSPy
         else
           "API request failed: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error making API request: #{e.message}"
       end
 
@@ -231,7 +231,7 @@ module DSPy
         else
           "Failed to fetch traffic views: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error fetching traffic views: #{e.message}"
       end
 
@@ -248,7 +248,7 @@ module DSPy
         else
           "Failed to fetch traffic clones: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error fetching traffic clones: #{e.message}"
       end
 

data/lib/dspy/tools/text_processing_toolset.rb

@@ -52,7 +52,7 @@ module DSPy
         else
           result
         end
-      rescue => e
+      rescue StandardError => e
         "Error running grep: #{e.message}"
       end
 
@@ -92,7 +92,7 @@ module DSPy
         else
           result
         end
-      rescue => e
+      rescue StandardError => e
         "Error running ripgrep: #{e.message}"
       end
 

data/lib/dspy/tools/toolset.rb

@@ -187,7 +187,7 @@ module DSPy
 
             @instance.send(@method_name, **kwargs)
           end
-        rescue => e
+        rescue StandardError => e
           "Error: #{e.message}"
         end
       end

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -141,7 +141,7 @@ module DSPy
       # Events are instant moments in time, not ongoing operations
       span = DSPy::Observability.start_span(event_name, flattened_attributes)
       DSPy::Observability.finish_span(span) if span
-    rescue => e
+    rescue StandardError => e
       # Log error but don't let it break the event system
       # Use emit_log directly to avoid infinite recursion
       emit_log('event.span_creation_error', {
@@ -221,8 +221,6 @@ require_relative 'dspy/lm'
 require_relative 'dspy/image'
 require_relative 'dspy/prediction'
 require_relative 'dspy/predict'
-require_relative 'dspy/events/subscribers'
-require_relative 'dspy/events/subscriber_mixin'
 require_relative 'dspy/chain_of_thought'
 require_relative 'dspy/re_act'
 require_relative 'dspy/evals'
@@ -248,7 +246,6 @@ begin
 rescue LoadError
 end
 require_relative 'dspy/tools'
-require_relative 'dspy/memory'
 
 begin
   require 'dspy/datasets'