dspy 0.30.0 → 0.31.0

data/lib/dspy/schema/sorbet_toon_adapter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'sorbet/toon'
+
+require_relative '../lm/errors'
+
+module DSPy
+  module Schema
+    module SorbetToonAdapter
+      extend T::Sig
+
+      module_function
+
+      sig { params(signature_class: T.nilable(T.class_of(DSPy::Signature)), values: T::Hash[Symbol, T.untyped]).returns(String) }
+      def render_input(signature_class, values)
+        Sorbet::Toon.encode(
+          values,
+          signature: signature_class,
+          role: :input
+        )
+      end
+
+      sig { params(signature_class: T.nilable(T.class_of(DSPy::Signature)), values: T::Hash[Symbol, T.untyped]).returns(String) }
+      def render_expected_output(signature_class, values)
+        Sorbet::Toon.encode(
+          values,
+          signature: signature_class,
+          role: :output
+        )
+      end
+
+      sig { params(signature_class: T.nilable(T.class_of(DSPy::Signature)), toon_string: String).returns(T.untyped) }
+      def parse_output(signature_class, toon_string)
+        payload = strip_code_fences(toon_string)
+
+        Sorbet::Toon.decode(
+          payload,
+          signature: signature_class,
+          role: :output
+        )
+      rescue Sorbet::Toon::DecodeError => e
+        log_decode_error(payload, e)
+        raise DSPy::LM::AdapterError,
+              "Failed to parse TOON response: #{e.message}. Ensure the model replies with a ```toon``` block using the schema described in the system prompt."
+      end
+
+      sig { params(text: T.nilable(String)).returns(String) }
+      def strip_code_fences(text)
+        return '' if text.nil?
+
+        match = text.match(/```(?:toon)?\s*(.*?)```/m)
+        return match[1].strip if match
+
+        text.strip
+      end
+
+      sig { params(payload: String, error: StandardError).void }
+      def log_decode_error(payload, error)
+        logger = DSPy.logger if DSPy.respond_to?(:logger)
+        return unless logger.respond_to?(:warn)
+
+        preview = payload.to_s.lines.first(5).join
+        logger.warn(
+          event: 'toon.decode_error',
+          error: error.message,
+          preview: preview,
+          length: payload.to_s.length
+        )
+      end
+
+      sig { params(signature_class: T.nilable(T.class_of(DSPy::Signature)), role: Symbol).returns(String) }
+      def field_guidance(signature_class, role)
+        return '' unless signature_class
+
+        Sorbet::Toon::SignatureFormatter.describe_signature(signature_class, role)
+      end
+    end
+  end
+end

data/lib/dspy/structured_outputs_prompt.rb

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

data/lib/dspy/type_serializer.rb

@@ -17,6 +17,7 @@ module DSPy
       when Hash
         value.transform_values { |v| serialize(v) }
       else
+        return serialize(value.serialize) if value.respond_to?(:serialize)
         value
       end
     end
@@ -52,4 +53,4 @@ module DSPy
       result
     end
   end
-end
+end

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -75,6 +75,10 @@ module DSPy
       create_event_span(event_name, attributes)
     end
 
+    attributes = attributes.dup
+    module_metadata = DSPy::Context.module_context_attributes
+    attributes.merge!(module_metadata) unless module_metadata.empty?
+
     # Perform the actual logging (original DSPy.log behavior)
     # emit_log(event_name, attributes)
 
@@ -100,6 +104,8 @@ module DSPy
     # Merge context automatically (but don't include span_stack)
     context = Context.current.dup
     context.delete(:span_stack)
+    context.delete(:otel_span_stack)
+    context.delete(:module_stack)
     attributes = context.merge(attributes)
     attributes[:event] = event_name
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-10-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -67,77 +66,49 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: openai
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.22.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.22.0
-- !ruby/object:Gem::Dependency
-  name: anthropic
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.0
-- !ruby/object:Gem::Dependency
-  name: gemini-ai
+  name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: sorbet-runtime
+  name: sorbet-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
-  name: sorbet-schema
+  name: sorbet-baml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: sorbet-baml
+  name: sorbet-toon
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -209,13 +180,6 @@ files:
 - lib/dspy/lm.rb
 - lib/dspy/lm/adapter.rb
 - lib/dspy/lm/adapter_factory.rb
-- lib/dspy/lm/adapters/anthropic_adapter.rb
-- lib/dspy/lm/adapters/gemini/schema_converter.rb
-- lib/dspy/lm/adapters/gemini_adapter.rb
-- 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/chat_strategy.rb
 - lib/dspy/lm/errors.rb
 - lib/dspy/lm/json_strategy.rb
@@ -248,6 +212,7 @@ files:
 - lib/dspy/registry/signature_registry.rb
 - lib/dspy/schema.rb
 - lib/dspy/schema/sorbet_json_schema.rb
+- lib/dspy/schema/sorbet_toon_adapter.rb
 - lib/dspy/schema/version.rb
 - lib/dspy/schema_adapters.rb
 - lib/dspy/signature.rb
@@ -275,7 +240,6 @@ homepage: https://github.com/vicentereig/dspy.rb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -290,8 +254,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: The Ruby framework for programming—rather than prompting—language models.
 test_files: []

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

@@ -1,291 +0,0 @@
-# frozen_string_literal: true
-
-require 'anthropic'
-require_relative '../vision_models'
-
-module DSPy
-  class LM
-    class AnthropicAdapter < Adapter
-      def initialize(model:, api_key:, structured_outputs: true)
-        super(model: model, api_key: api_key)
-        validate_api_key!(api_key, 'anthropic')
-        @client = Anthropic::Client.new(api_key: api_key)
-        @structured_outputs_enabled = structured_outputs
-      end
-
-      def chat(messages:, signature: nil, **extra_params, &block)
-        normalized_messages = normalize_messages(messages)
-        
-        # Validate vision support if images are present
-        if contains_images?(normalized_messages)
-          VisionModels.validate_vision_support!('anthropic', model)
-          # Convert messages to Anthropic format with proper image handling
-          normalized_messages = format_multimodal_messages(normalized_messages)
-        end
-        
-        # Anthropic requires system message to be separate from messages
-        system_message, user_messages = extract_system_message(normalized_messages)
-        
-        # Check if this is a tool use request
-        has_tools = extra_params.key?(:tools) && !extra_params[:tools].empty?
-        
-        # Apply JSON prefilling if needed for better Claude JSON compliance (but not for tool use)
-        unless has_tools || contains_images?(normalized_messages)
-          user_messages = prepare_messages_for_json(user_messages, system_message)
-        end
-        
-        request_params = {
-          model: model,
-          messages: user_messages,
-          max_tokens: 4096, # Required for Anthropic
-          temperature: 0.0 # DSPy default for deterministic responses
-        }.merge(extra_params)
-
-        # Add system message if present
-        request_params[:system] = system_message if system_message
-
-        # Add streaming if block provided
-        if block_given?
-          request_params[:stream] = true
-        end
-
-        begin
-          if block_given?
-            content = ""
-            @client.messages.stream(**request_params) do |chunk|
-              if chunk.respond_to?(:delta) && chunk.delta.respond_to?(:text)
-                chunk_text = chunk.delta.text
-                content += chunk_text
-                block.call(chunk)
-              end
-            end
-            
-            # Create typed metadata for streaming response
-            metadata = ResponseMetadataFactory.create('anthropic', {
-              model: model,
-              streaming: true
-            })
-            
-            Response.new(
-              content: content,
-              usage: nil, # Usage not available in streaming
-              metadata: metadata
-            )
-          else
-            response = @client.messages.create(**request_params)
-            
-            if response.respond_to?(:error) && response.error
-              raise AdapterError, "Anthropic API error: #{response.error}"
-            end
-
-            # Handle both text content and tool use
-            content = ""
-            tool_calls = []
-            
-            if response.content.is_a?(Array)
-              response.content.each do |content_block|
-                case content_block.type.to_s
-                when "text"
-                  content += content_block.text
-                when "tool_use"
-                  tool_calls << {
-                    id: content_block.id,
-                    name: content_block.name,
-                    input: content_block.input
-                  }
-                end
-              end
-            end
-            
-            usage = response.usage
-
-            # Convert usage data to typed struct
-            usage_struct = UsageFactory.create('anthropic', usage)
-            
-            metadata = {
-              provider: 'anthropic',
-              model: model,
-              response_id: response.id,
-              role: response.role
-            }
-            
-            # Add tool calls to metadata if present
-            metadata[:tool_calls] = tool_calls unless tool_calls.empty?
-            
-            # Create typed metadata
-            typed_metadata = ResponseMetadataFactory.create('anthropic', metadata)
-            
-            Response.new(
-              content: content,
-              usage: usage_struct,
-              metadata: typed_metadata
-            )
-          end
-        rescue => e
-          # Check for specific image-related errors in the message
-          error_msg = e.message.to_s
-          
-          if error_msg.include?('Could not process image')
-            raise AdapterError, "Image processing failed: #{error_msg}. Ensure your image is a valid PNG, JPEG, GIF, or WebP format, properly base64-encoded, and under 5MB."
-          elsif error_msg.include?('image')
-            raise AdapterError, "Image error: #{error_msg}. Anthropic requires base64-encoded images (URLs are not supported)."
-          elsif error_msg.include?('rate')
-            raise AdapterError, "Anthropic rate limit exceeded: #{error_msg}. Please wait and try again."
-          elsif error_msg.include?('authentication') || error_msg.include?('API key')
-            raise AdapterError, "Anthropic authentication failed: #{error_msg}. Check your API key."
-          else
-            # Generic error handling
-            raise AdapterError, "Anthropic adapter error: #{e.message}"
-          end
-        end
-      end
-
-      private
-
-      # Enhanced JSON extraction specifically for Claude models
-      # Handles multiple patterns of markdown-wrapped JSON responses
-      def extract_json_from_response(content)
-        return content if content.nil? || content.empty?
-        
-        # Pattern 1: ```json blocks
-        if content.include?('```json')
-          extracted = content[/```json\s*\n(.*?)\n```/m, 1]
-          return extracted.strip if extracted
-        end
-        
-        # Pattern 2: ## Output values header
-        if content.include?('## Output values')
-          extracted = content.split('## Output values').last
-                            .gsub(/```json\s*\n/, '')
-                            .gsub(/\n```.*/, '')
-                            .strip
-          return extracted if extracted && !extracted.empty?
-        end
-        
-        # Pattern 3: Generic code blocks (check if it looks like JSON)
-        if content.include?('```')
-          extracted = content[/```\s*\n(.*?)\n```/m, 1]
-          return extracted.strip if extracted && looks_like_json?(extracted)
-        end
-        
-        # Pattern 4: Already valid JSON or fallback
-        content.strip
-      end
-
-      # Simple heuristic to check if content looks like JSON
-      def looks_like_json?(str)
-        return false if str.nil? || str.empty?
-        trimmed = str.strip
-        (trimmed.start_with?('{') && trimmed.end_with?('}')) ||
-        (trimmed.start_with?('[') && trimmed.end_with?(']'))
-      end
-
-      # Prepare messages for JSON output by adding prefilling and strong instructions
-      def prepare_messages_for_json(user_messages, system_message)
-        return user_messages unless requires_json_output?(user_messages, system_message)
-        return user_messages unless tends_to_wrap_json?
-        
-        # Add strong JSON instruction to the last user message if not already present
-        enhanced_messages = enhance_json_instructions(user_messages)
-        
-        # Only add prefill for models that support it and temporarily disable for testing
-        if false # supports_prefilling? - temporarily disabled
-          add_json_prefill(enhanced_messages)
-        else
-          enhanced_messages
-        end
-      end
-
-      # Detect if the conversation requires JSON output
-      def requires_json_output?(user_messages, system_message)
-        # Check for JSON-related keywords in messages
-        all_content = [system_message] + user_messages.map { |m| m[:content] }
-        all_content.compact.any? do |content|
-          content.downcase.include?('json') || 
-          content.include?('```') ||
-          content.include?('{') ||
-          content.include?('output')
-        end
-      end
-
-      # Check if this is a Claude model that benefits from prefilling
-      def supports_prefilling?
-        # Claude models that work well with JSON prefilling
-        model.downcase.include?('claude')
-      end
-
-      # Check if this is a Claude model that tends to wrap JSON in markdown
-      def tends_to_wrap_json?
-        # All Claude models have this tendency, especially Opus variants
-        model.downcase.include?('claude')
-      end
-
-      # Enhance the last user message with strong JSON instructions
-      def enhance_json_instructions(user_messages)
-        return user_messages if user_messages.empty?
-        
-        enhanced_messages = user_messages.dup
-        last_message = enhanced_messages.last
-        
-        # Only add instruction if not already present
-        unless last_message[:content].include?('ONLY valid JSON')
-          # Use smart default instruction for Claude models
-          json_instruction = "\n\nIMPORTANT: Respond with ONLY valid JSON. No markdown formatting, no code blocks, no explanations. Start your response with '{' and end with '}'."
-          
-          last_message = last_message.dup
-          last_message[:content] = last_message[:content] + json_instruction
-          enhanced_messages[-1] = last_message
-        end
-        
-        enhanced_messages
-      end
-
-      # Add assistant message prefill to guide Claude
-      def add_json_prefill(user_messages)
-        user_messages + [{ role: "assistant", content: "{" }]
-      end
-
-      def extract_system_message(messages)
-        system_message = nil
-        user_messages = []
-
-        messages.each do |msg|
-          if msg[:role] == 'system'
-            system_message = msg[:content]
-          else
-            user_messages << msg
-          end
-        end
-
-        [system_message, user_messages]
-      end
-      
-      def format_multimodal_messages(messages)
-        messages.map do |msg|
-          if msg[:content].is_a?(Array)
-            # Convert multimodal content to Anthropic format
-            formatted_content = msg[:content].map do |item|
-              case item[:type]
-              when 'text'
-                { type: 'text', text: item[:text] }
-              when 'image'
-                # Validate image compatibility before formatting
-                item[:image].validate_for_provider!('anthropic')
-                item[:image].to_anthropic_format
-              else
-                item
-              end
-            end
-            
-            {
-              role: msg[:role],
-              content: formatted_content
-            }
-          else
-            msg
-          end
-        end
-      end
-    end
-  end
-end