dspy 0.20.1 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3324f833b373e826df1dcdf3f2c3f46011e192e9a30fdf38d7db1b9cc51a7950
-  data.tar.gz: f6159081bc6429d0c57e6275111d2672bf984f8500be7756afbf8bb17599dd19
+  metadata.gz: 78e01258a3b9b5a1bccddad913a1d0aa45ecb145a65adb3e691986cadbea6e23
+  data.tar.gz: 9a778ea689150002e0766357dd4aa4af526be81979378b9996ba9067c2cdbd42
 SHA512:
-  metadata.gz: cd81596af2ea0d734550b0827e18b71d4abdd1e3a4c92efb014af665d17bb2a37fb36b747757eb3ad4377d89a435b81bbaa4477ce0fd22b8ed88319ebc8b1f5b
-  data.tar.gz: d65e68af35f7ced5e97524dd85f1c590900f33b720038f25bbc22995031d10cc5115bdb1b160b153e5fbaa5bf2cb3809dde0520f6bd99a7ac348c0231bf88afa
+  metadata.gz: 7ba1376b844e5c5e61215b961142a70f82d758db41e061bf2e7404f4ffdbae867197b0c38254a92b25892beb51922fb3c3b963ab2474494c9d490b83814bba5d
+  data.tar.gz: 4a543e0b954469f316f003f36c5a55b97b0794ef1cbf395180ac5197acf5d4091bfe3ea87e342473c190d96adf5761baff59532502a20778edea23a83a9e5253

data/README.md

@@ -14,6 +14,10 @@ Traditional prompting is like writing code with string concatenation: it works u
 the programming approach pioneered by [dspy.ai](https://dspy.ai/): instead of crafting fragile prompts, you define modular 
 signatures and let the framework handle the messy details.
 
+DSPy.rb is an idiomatic Ruby port of Stanford's [DSPy framework](https://github.com/stanfordnlp/dspy). While implementing 
+the core concepts of signatures, predictors, and optimization from the original Python library, DSPy.rb embraces Ruby 
+conventions and adds Ruby-specific innovations like CodeAct agents and enhanced production instrumentation.
+
 The result? LLM applications that actually scale and don't break when you sneeze.
 
 ## Your First DSPy Program

data/lib/dspy/lm/strategies/enhanced_prompting_strategy.rb

@@ -114,24 +114,55 @@ module DSPy
 
           example = {}
           schema[:properties].each do |field_name, field_schema|
-            example[field_name.to_s] = case field_schema[:type]
-            when "string"
-              field_schema[:description] || "example string"
-            when "integer"
-              42
-            when "number"
-              3.14
-            when "boolean"
-              true
-            when "array"
+            example[field_name.to_s] = generate_example_value(field_schema)
+          end
+          example
+        end
+
+        sig { params(field_schema: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+        def generate_example_value(field_schema)
+          case field_schema[:type]
+          when "string"
+            field_schema[:description] || "example string"
+          when "integer"
+            42
+          when "number"
+            3.14
+          when "boolean"
+            true
+          when "array"
+            if field_schema[:items]
+              [generate_example_value(field_schema[:items])]
+            else
               ["example item"]
-            when "object"
+            end
+          when "object"
+            if field_schema[:properties]
+              # Generate proper nested object example
+              nested_example = {}
+              field_schema[:properties].each do |prop_name, prop_schema|
+                nested_example[prop_name.to_s] = generate_example_value(prop_schema)
+              end
+              nested_example
+            else
               { "nested" => "object" }
+            end
+          when Array
+            # Handle union types like ["object", "null"]
+            if field_schema[:type].include?("object") && field_schema[:properties]
+              nested_example = {}
+              field_schema[:properties].each do |prop_name, prop_schema|
+                nested_example[prop_name.to_s] = generate_example_value(prop_schema)
+              end
+              nested_example
+            elsif field_schema[:type].include?("string")
+              "example string"
             else
               "example value"
             end
+          else
+            "example value"
           end
-          example
         end
 
         sig { params(content: String).returns(T::Boolean) }

data/lib/dspy/signature.rb

@@ -188,6 +188,11 @@ module DSPy
           return { type: "boolean" }
         end
 
+        # Handle type aliases by resolving to their underlying type
+        if type.is_a?(T::Private::Types::TypeAlias)
+          return type_to_json_schema(type.aliased_type)
+        end
+
         # Handle raw class types first
         if type.is_a?(Class)
           if type < T::Enum
@@ -257,6 +262,22 @@ module DSPy
             # Add a more explicit description of the expected structure
             description: "A mapping where keys are #{key_schema[:type]}s and values are #{value_schema[:description] || value_schema[:type]}s"
           }
+        elsif type.is_a?(T::Types::FixedHash)
+          # Handle fixed hashes (from type aliases like { "key" => Type })
+          properties = {}
+          required = []
+          
+          type.types.each do |key, value_type|
+            properties[key] = type_to_json_schema(value_type)
+            required << key
+          end
+          
+          {
+            type: "object",
+            properties: properties,
+            required: required,
+            additionalProperties: false
+          }
         elsif type.class.name == "T::Private::Types::SimplePairUnion"
           # Handle T.nilable types (T::Private::Types::SimplePairUnion)
           # This is the actual implementation of T.nilable(SomeType)

data/lib/dspy/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.20.1
+  version: 0.21.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-08-27 00:00:00.000000000 Z
+date: 2025-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable