dspy 0.5.1 → 0.6.0

data/lib/dspy/tools/toolset.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'json'
+
+module DSPy
+  module Tools
+    # Base class for multi-method tool classes where each method can be exposed as an individual tool
+    # Similar to Rails controllers where each action is exposed as an endpoint
+    class Toolset
+      extend T::Sig
+      extend T::Helpers
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Hash[Symbol, T::Hash[Symbol, String]]) }
+        attr_reader :exposed_tools
+
+        # DSL method to expose a method as a tool
+        sig { params(method_name: Symbol, tool_name: T.nilable(String), description: T.nilable(String)).void }
+        def tool(method_name, tool_name: nil, description: nil)
+          @exposed_tools ||= {}
+          @exposed_tools[method_name] = {
+            tool_name: tool_name || "#{toolset_name}_#{method_name}",
+            description: description || "#{method_name.to_s.tr('_', ' ').capitalize} operation"
+          }
+        end
+
+        # DSL method to set the toolset name prefix
+        sig { params(name: T.nilable(String)).returns(String) }
+        def toolset_name(name = nil)
+          if name
+            @toolset_name = name
+          else
+            @toolset_name || self.name.split('::').last.gsub(/Toolset$/, '').downcase
+          end
+        end
+
+        # Get all exposed tools as individual tool instances
+        sig { returns(T::Array[ToolProxy]) }
+        def to_tools
+          instance = new
+          (@exposed_tools || {}).map do |method_name, config|
+            ToolProxy.new(instance, method_name, config[:tool_name], config[:description])
+          end
+        end
+
+        # Generate schema for a specific method using Sorbet signatures
+        sig { params(method_name: Symbol).returns(T::Hash[Symbol, T.untyped]) }
+        def schema_for_method(method_name)
+          method_obj = instance_method(method_name)
+          sig_info = T::Utils.signature_for_method(method_obj)
+
+          if sig_info.nil?
+            # Fallback for methods without signatures
+            return {
+              type: :object,
+              properties: {},
+              required: []
+            }
+          end
+
+          # Reuse the schema generation logic from Base
+          properties = {}
+          required = []
+
+          # Handle keyword arguments (most common in Ruby)
+          sig_info.kwarg_types.each do |param_name, param_type|
+            next if param_name == :block
+
+            properties[param_name] = {
+              type: sorbet_type_to_json_schema(param_type)[:type],
+              description: "Parameter #{param_name}"
+            }
+
+            # Check if parameter is required
+            if sig_info.req_kwarg_names.include?(param_name)
+              required << param_name.to_s
+            else
+              properties[param_name][:description] += " (optional)"
+            end
+          end
+
+          {
+            type: :object,
+            properties: properties,
+            required: required
+          }
+        end
+
+        private
+
+        # Convert Sorbet types to JSON Schema types (extracted from Base)
+        sig { params(sorbet_type: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+        def sorbet_type_to_json_schema(sorbet_type)
+          # Check for boolean types first (SimplePairUnion of TrueClass | FalseClass)
+          if sorbet_type.respond_to?(:types) && sorbet_type.types.length == 2
+            raw_types = sorbet_type.types.map do |t|
+              t.is_a?(T::Types::Simple) ? t.raw_type : t
+            end
+            
+            if raw_types.include?(TrueClass) && raw_types.include?(FalseClass)
+              return { type: :boolean }
+            end
+          end
+          
+          if sorbet_type.is_a?(T::Types::Simple)
+            raw_type = sorbet_type.raw_type
+
+            case raw_type
+            when String
+              { type: :string }
+            when Integer
+              { type: :integer }
+            when Float, Numeric
+              { type: :number }
+            when TrueClass, FalseClass, T::Boolean
+              { type: :boolean }
+            else
+              { type: :string, description: "#{raw_type} (converted to string)" }
+            end
+          elsif sorbet_type.is_a?(T::Types::Union)
+            # Handle nilable types
+            non_nil_types = sorbet_type.types.reject { |t| t == T::Utils.coerce(NilClass) }
+            if non_nil_types.length == 1
+              result = sorbet_type_to_json_schema(non_nil_types.first)
+              result[:description] = "#{result[:description] || ''} (optional)".strip
+              result
+            else
+              { type: :string, description: "Union type (converted to string)" }
+            end
+          elsif sorbet_type.is_a?(T::Types::TypedArray)
+            {
+              type: :array,
+              items: sorbet_type_to_json_schema(sorbet_type.type)
+            }
+          else
+            { type: :string, description: "#{sorbet_type} (converted to string)" }
+          end
+        end
+      end
+
+      # Inner class that wraps a method as a tool, compatible with DSPy::Tools::Base interface
+      class ToolProxy < Base
+        extend T::Sig
+
+        sig { params(instance: Toolset, method_name: Symbol, tool_name: String, description: String).void }
+        def initialize(instance, method_name, tool_name, description)
+          @instance = instance
+          @method_name = method_name
+          @tool_name_override = tool_name
+          @description_override = description
+        end
+
+        sig { override.returns(String) }
+        def name
+          @tool_name_override
+        end
+
+        sig { override.returns(String) }
+        def description
+          @description_override
+        end
+
+        sig { override.returns(String) }
+        def schema
+          schema_obj = @instance.class.schema_for_method(@method_name)
+          tool_info = {
+            name: name,
+            description: description,
+            parameters: schema_obj
+          }
+          JSON.generate(tool_info)
+        end
+
+        # The main call method that tools must implement
+        sig { params(kwargs: T.untyped).returns(T.untyped) }
+        def call(**kwargs)
+          @instance.send(@method_name, **kwargs)
+        end
+
+        sig { override.params(args_json: T.untyped).returns(T.untyped) }
+        def dynamic_call(args_json)
+          schema = @instance.class.schema_for_method(@method_name)
+
+          if schema[:properties].empty?
+            @instance.send(@method_name)
+          else
+            # Parse arguments
+            args = case args_json
+                  when Hash
+                    args_json
+                  when String
+                    begin
+                      JSON.parse(args_json)
+                    rescue JSON::ParserError
+                      return "Error: Invalid JSON input"
+                    end
+                  else
+                    return "Error: Expected Hash or JSON string"
+                  end
+
+            # Convert string keys to symbols and validate types
+            kwargs = {}
+            schema[:properties].each do |param_name, param_schema|
+              key = param_name.to_s
+              if args.key?(key)
+                kwargs[param_name] = convert_argument_type(args[key], param_schema)
+              elsif schema[:required].include?(key)
+                return "Error: Missing required parameter: #{key}"
+              end
+            end
+
+            @instance.send(@method_name, **kwargs)
+          end
+        rescue => e
+          "Error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/dspy/tools.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'tools/base'
+require_relative 'tools/toolset'
 
 module DSPy
   # Define the tools available to the agent

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -112,6 +112,7 @@ require_relative 'dspy/lm'
 require_relative 'dspy/predict'
 require_relative 'dspy/chain_of_thought'
 require_relative 'dspy/re_act'
+require_relative 'dspy/code_act'
 require_relative 'dspy/evaluate'
 require_relative 'dspy/teleprompt/teleprompter'
 require_relative 'dspy/teleprompt/utils'
@@ -121,6 +122,7 @@ require_relative 'dspy/teleprompt/simple_optimizer'
 require_relative 'dspy/teleprompt/mipro_v2'
 require_relative 'dspy/subscribers/logger_subscriber'
 require_relative 'dspy/tools'
+require_relative 'dspy/memory'
 require_relative 'dspy/instrumentation'
 require_relative 'dspy/storage/program_storage'
 require_relative 'dspy/storage/storage_manager'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-07-04 00:00:00.000000000 Z
+date: 2025-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -135,6 +135,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.20.0
+- !ruby/object:Gem::Dependency
+  name: informers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: A Ruby implementation of DSPy, a framework for programming with large
   language models
 email:
@@ -146,6 +160,7 @@ files:
 - README.md
 - lib/dspy.rb
 - lib/dspy/chain_of_thought.rb
+- lib/dspy/code_act.rb
 - lib/dspy/evaluate.rb
 - lib/dspy/example.rb
 - lib/dspy/few_shot_example.rb
@@ -159,6 +174,14 @@ files:
 - lib/dspy/lm/adapters/openai_adapter.rb
 - lib/dspy/lm/errors.rb
 - lib/dspy/lm/response.rb
+- lib/dspy/memory.rb
+- lib/dspy/memory/embedding_engine.rb
+- lib/dspy/memory/in_memory_store.rb
+- lib/dspy/memory/local_embedding_engine.rb
+- lib/dspy/memory/memory_compactor.rb
+- lib/dspy/memory/memory_manager.rb
+- lib/dspy/memory/memory_record.rb
+- lib/dspy/memory/memory_store.rb
 - lib/dspy/mixins/instrumentation_helpers.rb
 - lib/dspy/mixins/struct_builder.rb
 - lib/dspy/mixins/type_coercion.rb
@@ -184,6 +207,9 @@ files:
 - lib/dspy/teleprompt/utils.rb
 - lib/dspy/tools.rb
 - lib/dspy/tools/base.rb
+- lib/dspy/tools/memory_toolset.rb
+- lib/dspy/tools/text_processing_toolset.rb
+- lib/dspy/tools/toolset.rb
 - lib/dspy/version.rb
 homepage: https://github.com/vicentereig/dspy.rb
 licenses: