dspy 0.34.3 → 1.0.0

data/lib/dspy/lm/message.rb

@@ -59,6 +59,8 @@ module DSPy
               { type: 'text', text: item[:text] }
             when 'image'
               item[:image].to_openai_format
+            when 'document'
+              item[:document].to_openai_format
             else
               item
             end
@@ -83,6 +85,8 @@ module DSPy
               { type: 'text', text: item[:text] }
             when 'image'
               item[:image].to_anthropic_format
+            when 'document'
+              item[:document].to_anthropic_format
             else
               item
             end
@@ -160,4 +164,4 @@ module DSPy
       end
     end
   end
-end
+end

data/lib/dspy/lm/message_builder.rb

@@ -68,6 +68,20 @@ module DSPy
         )
         self
       end
+
+      sig { params(text: String, document: DSPy::Document).returns(MessageBuilder) }
+      def user_with_document(text, document)
+        content_array = [
+          { type: 'text', text: text },
+          { type: 'document', document: document }
+        ]
+
+        @messages << Message.new(
+          role: Message::Role::User,
+          content: content_array
+        )
+        self
+      end
       
       # For backward compatibility, allow conversion to hash array
       sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
@@ -76,4 +90,4 @@ module DSPy
       end
     end
   end
-end
+end

data/lib/dspy/lm/response.rb

@@ -118,7 +118,7 @@ module DSPy
       extend T::Sig
       
       const :content, String
-      const :usage, T.nilable(T.any(Usage, OpenAIUsage)), default: nil
+      const :usage, T.nilable(T.any(Usage, OpenAIUsage, AnthropicUsage)), default: nil
       const :metadata, T.any(ResponseMetadata, OpenAIResponseMetadata, AnthropicResponseMetadata, GeminiResponseMetadata, T::Hash[Symbol, T.untyped])
       
       sig { returns(String) }

data/lib/dspy/lm/usage.rb

@@ -45,11 +45,34 @@ module DSPy
       end
     end
     
+    # Anthropic-specific usage information with cache token fields
+    class AnthropicUsage < T::Struct
+      extend T::Sig
+
+      const :input_tokens, Integer
+      const :output_tokens, Integer
+      const :total_tokens, Integer
+      const :cache_creation_input_tokens, T.nilable(Integer), default: nil
+      const :cache_read_input_tokens, T.nilable(Integer), default: nil
+
+      sig { returns(Hash) }
+      def to_h
+        base = {
+          input_tokens: input_tokens,
+          output_tokens: output_tokens,
+          total_tokens: total_tokens
+        }
+        base[:cache_creation_input_tokens] = cache_creation_input_tokens unless cache_creation_input_tokens.nil?
+        base[:cache_read_input_tokens] = cache_read_input_tokens unless cache_read_input_tokens.nil?
+        base
+      end
+    end
+
     # Factory for creating appropriate usage objects
     module UsageFactory
       extend T::Sig
       
-      sig { params(provider: String, usage_data: T.untyped).returns(T.nilable(T.any(Usage, OpenAIUsage))) }
+      sig { params(provider: String, usage_data: T.untyped).returns(T.nilable(T.any(Usage, OpenAIUsage, AnthropicUsage))) }
       def self.create(provider, usage_data)
         return nil if usage_data.nil?
         
@@ -121,17 +144,19 @@ module DSPy
         nil
       end
       
-      sig { params(data: T::Hash[Symbol, T.untyped]).returns(T.nilable(Usage)) }
+      sig { params(data: T::Hash[Symbol, T.untyped]).returns(T.nilable(AnthropicUsage)) }
       def self.create_anthropic_usage(data)
         # Anthropic uses input_tokens/output_tokens
         input_tokens = data[:input_tokens] || 0
         output_tokens = data[:output_tokens] || 0
         total_tokens = data[:total_tokens] || (input_tokens + output_tokens)
-        
-        Usage.new(
+
+        AnthropicUsage.new(
           input_tokens: input_tokens,
           output_tokens: output_tokens,
-          total_tokens: total_tokens
+          total_tokens: total_tokens,
+          cache_creation_input_tokens: data[:cache_creation_input_tokens],
+          cache_read_input_tokens: data[:cache_read_input_tokens]
         )
       rescue StandardError => e
         DSPy.logger.debug("Failed to create Anthropic usage: #{e.message}")
@@ -173,4 +198,4 @@ module DSPy
       end
     end
   end
-end
+end

data/lib/dspy/lm.rb

@@ -161,16 +161,78 @@ module DSPy
         )
       end
 
-      # Add user message
-      user_prompt = prompt.render_user_prompt(input_values)
-      messages << Message.new(
-        role: Message::Role::User,
-        content: user_prompt
-      )
+      document_inputs = extract_document_inputs(input_values)
+
+      if document_inputs.empty?
+        user_prompt = prompt.render_user_prompt(input_values)
+        messages << Message.new(
+          role: Message::Role::User,
+          content: user_prompt
+        )
+      else
+        validate_document_predict_support!(input_values, document_inputs)
+
+        placeholder_inputs = input_values.transform_values do |value|
+          value.is_a?(DSPy::Document) ? "[attached pdf document]" : value
+        end
+
+        user_prompt = prompt.render_user_prompt(placeholder_inputs)
+        content_array = [
+          { type: 'text', text: user_prompt },
+          { type: 'document', document: document_inputs.first.last }
+        ]
+
+        messages << Message.new(
+          role: Message::Role::User,
+          content: content_array
+        )
+      end
 
       messages
     end
 
+    def extract_document_inputs(input_values)
+      input_values.each_with_object([]) do |(key, value), inputs|
+        if value.is_a?(DSPy::Document)
+          inputs << [key, value]
+        elsif nested_document_input?(value)
+          raise DSPy::LM::IncompatibleDocumentFeatureError,
+                "Only one top-level DSPy::Document input is currently supported in Predict."
+        end
+      end
+    end
+
+    def nested_document_input?(value)
+      case value
+      when T::Struct
+        value.class.props.any? { |name, _| nested_document_input?(value.public_send(name)) }
+      when Array
+        value.any? { |item| nested_document_input?(item) }
+      when Hash
+        value.values.any? { |item| nested_document_input?(item) }
+      else
+        value.is_a?(DSPy::Document)
+      end
+    end
+
+    def validate_document_predict_support!(input_values, document_inputs)
+      if document_inputs.length > 1
+        raise DSPy::LM::IncompatibleDocumentFeatureError,
+              "Only one top-level DSPy::Document input is currently supported in Predict."
+      end
+
+      if input_values.values.any? { |value| value.is_a?(DSPy::Image) }
+        raise DSPy::LM::IncompatibleDocumentFeatureError,
+              "Predict does not support mixing DSPy::Document and DSPy::Image inputs in this release."
+      end
+
+      return if provider == 'anthropic'
+      return if adapter.class.name.include?('RubyLLMAdapter') && adapter.provider == 'anthropic'
+
+      raise DSPy::LM::IncompatibleDocumentFeatureError,
+            "Document inputs are currently supported only for Anthropic models and Anthropic via RubyLLM."
+    end
+
     def will_use_structured_outputs?(signature_class, data_format: nil)
       return false unless signature_class
       return false if data_format == :toon
@@ -305,6 +367,12 @@ module DSPy
             span.set_attribute('gen_ai.usage.prompt_tokens', usage.input_tokens) if usage.input_tokens
             span.set_attribute('gen_ai.usage.completion_tokens', usage.output_tokens) if usage.output_tokens
             span.set_attribute('gen_ai.usage.total_tokens', usage.total_tokens) if usage.total_tokens
+            if usage.respond_to?(:cache_creation_input_tokens) && !usage.cache_creation_input_tokens.nil?
+              span.set_attribute('gen_ai.usage.cache_creation_input_tokens', usage.cache_creation_input_tokens)
+            end
+            if usage.respond_to?(:cache_read_input_tokens) && !usage.cache_read_input_tokens.nil?
+              span.set_attribute('gen_ai.usage.cache_read_input_tokens', usage.cache_read_input_tokens)
+            end
           end
         end
 
@@ -356,11 +424,16 @@ module DSPy
       
       # Handle Usage struct objects
       if response.usage.respond_to?(:input_tokens)
-        return {
+        result = {
           input_tokens: response.usage.input_tokens,
           output_tokens: response.usage.output_tokens,
           total_tokens: response.usage.total_tokens
-        }.compact
+        }
+        if response.usage.respond_to?(:cache_creation_input_tokens)
+          result[:cache_creation_input_tokens] = response.usage.cache_creation_input_tokens
+          result[:cache_read_input_tokens] = response.usage.cache_read_input_tokens
+        end
+        return result.compact
       end
       
       # Handle hash-based usage (for VCR compatibility)

data/lib/dspy/mixins/type_coercion.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
+require 'yaml'
 
 module DSPy
   module Mixins
@@ -88,6 +89,15 @@ module DSPy
         case prop_type
         when ->(type) { union_type?(type) }
           coerce_union_value(value, prop_type)
+        when ->(type) { nilable_type?(type) }
+          # Unwrap T.nilable(X) to coerce as X (nil already handled above)
+          non_nil_types = prop_type.types.reject { |t| t == T::Utils.coerce(NilClass) }
+          if non_nil_types.size == 1
+            coerce_value_to_type(value, non_nil_types.first)
+          else
+            # T.any(A, B, NilClass) — rebuild as T.any(A, B) and coerce as union
+            coerce_union_value(value, T::Types::Union.new(non_nil_types))
+          end
         when ->(type) { array_type?(type) }
           coerce_array_value(value, prop_type)
         when ->(type) { hash_type?(type) }
@@ -161,15 +171,31 @@ module DSPy
       # Checks if a type is a union type (T.any)
       sig { params(type: T.untyped).returns(T::Boolean) }
       def union_type?(type)
-        type.is_a?(T::Types::Union) && !is_nilable_type?(type)
+        type.is_a?(T::Types::Union) && !nilable_type?(type)
       end
 
       # Checks if a type is nilable (contains NilClass)
       sig { params(type: T.untyped).returns(T::Boolean) }
-      def is_nilable_type?(type)
+      def nilable_type?(type)
         type.is_a?(T::Types::Union) && type.types.any? { |t| t == T::Utils.coerce(NilClass) }
       end
 
+      # Checks if a union type is a simple nilable struct (T.nilable(SomeStruct))
+      # Returns true only if the union has exactly 2 types: NilClass and a Struct
+      sig { params(union_type: T.untyped).returns(T::Boolean) }
+      def nilable_struct_union?(union_type)
+        return false unless union_type.is_a?(T::Types::Union)
+
+        types = union_type.types
+        return false unless types.size == 2
+
+        # One type must be NilClass, the other must be a struct
+        has_nil = types.any? { |t| t == T::Utils.coerce(NilClass) }
+        struct_type = types.find { |t| t != T::Utils.coerce(NilClass) && struct_type?(t) }
+
+        has_nil && !struct_type.nil?
+      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)
@@ -283,9 +309,11 @@ module DSPy
       # Coerces a hash value, converting keys and values as needed
       sig { params(value: T.untyped, prop_type: T.untyped).returns(T.untyped) }
       def coerce_hash_value(value, prop_type)
-        return value unless value.is_a?(Hash)
         return value unless prop_type.is_a?(T::Types::TypedHash)
-        
+
+        value = try_parse_string_to_hash(value)
+        return value unless value.is_a?(Hash)
+
         key_type = prop_type.keys
         value_type = prop_type.values
         
@@ -302,9 +330,41 @@ module DSPy
         result.transform_values { |v| coerce_value_to_type(v, value_type) }
       end
 
+      # Attempts to parse a string into a Hash.
+      # Returns the parsed Hash on success, or the original value otherwise.
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def try_parse_string_to_hash(value)
+        return value unless value.is_a?(String)
+
+        parsed = begin
+          JSON.parse(value)
+        rescue JSON::ParserError
+          YAML.safe_load(value, permitted_classes: [Symbol, Date, Time])
+        end
+
+        parsed.is_a?(Hash) ? parsed : value
+      rescue Psych::SyntaxError
+        value
+      end
+
+      # Attempts to parse a JSON string into a Hash.
+      # Returns the parsed Hash on success, or the original value otherwise.
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def try_parse_json_to_hash(value)
+        return value unless value.is_a?(String)
+
+        parsed = JSON.parse(value)
+        parsed.is_a?(Hash) ? parsed : value
+      rescue JSON::ParserError
+        value
+      end
+
       # Coerces a struct value from a hash
       sig { params(value: T.untyped, prop_type: T.untyped).returns(T.untyped) }
       def coerce_struct_value(value, prop_type)
+        # Anthropic tool use may return struct fields as JSON strings
+        value = try_parse_json_to_hash(value)
+
         return value unless value.is_a?(Hash)
 
         struct_class = if prop_type.is_a?(Class)
@@ -347,7 +407,7 @@ module DSPy
           next false unless prop_info
           prop_type = prop_info[:type_object] || prop_info[:type]
           has_default = prop_info.key?(:default) || prop_info[:fully_optional]
-          !is_nilable_type?(prop_type) && has_default
+          !nilable_type?(prop_type) && has_default
         end
 
         # Create the struct instance
@@ -363,18 +423,20 @@ module DSPy
       def coerce_union_value(value, union_type)
         # Anthropic tool use may return complex oneOf union fields as JSON strings
         # instead of nested objects. Parse them back into Hashes for coercion.
-        if value.is_a?(String)
-          begin
-            parsed = JSON.parse(value)
-            value = parsed if parsed.is_a?(Hash)
-          rescue JSON::ParserError
-            # Not JSON — fall through
-          end
-        end
+        value = try_parse_json_to_hash(value)
 
         return value unless value.is_a?(Hash)
 
-        # Check for _type discriminator field
+        # Handle nilable struct unions (T.nilable(SomeStruct)) without _type discriminator
+        # LLMs don't provide _type for simple nilable structs, so we can directly coerce
+        if nilable_struct_union?(union_type)
+          struct_type = union_type.types.find { |t|
+            t != T::Utils.coerce(NilClass) && struct_type?(t)
+          }
+          return coerce_struct_value(value, struct_type) if struct_type
+        end
+
+        # Check for _type discriminator field (required for true multi-type unions)
         type_name = value[:_type] || value["_type"]
         return value unless type_name
 

data/lib/dspy/module.rb

@@ -261,21 +261,64 @@ module DSPy
     def instrument_forward_call(call_args, call_kwargs)
       ensure_module_subscriptions!
 
+      input_json = serialize_module_input(call_args, call_kwargs)
+      root_call = DSPy::Context.current[:span_stack].empty?
+
       DSPy::Context.with_module(self) do
         observation_type = DSPy::ObservationType.for_module_class(self.class)
         span_attributes = observation_type.langfuse_attributes.merge(
-          'langfuse.observation.input' => serialize_module_input(call_args, call_kwargs),
+          'langfuse.observation.input' => input_json,
           'dspy.module' => self.class.name
         )
+        operation_name = "#{self.class.name}.forward"
+        span_attributes.merge!(root_trace_attributes(call_args, call_kwargs, input_json)) if root_call
+
+        if self.class.name == 'DSPy::Predict' && respond_to?(:signature_class)
+          signature_name = signature_class&.name
+          span_attributes['dspy.signature'] = signature_name || 'anonymous'
+          span_attributes['dspy.signature_kind'] = infer_signature_kind(signature_name)
+          span_attributes['dspy.predictor_label'] = module_scope_label if module_scope_label
+          operation_name = "DSPy::Predict(#{signature_name}).forward" if signature_name
+        end
 
         DSPy::Context.with_span(
-          operation: "#{self.class.name}.forward",
+          operation: operation_name,
           **span_attributes
         ) do |span|
-          yield.tap do |result|
-            if span && result
-              span.set_attribute('langfuse.observation.output', serialize_module_output(result))
+          begin
+            yield.tap do |result|
+              if span && !result.nil?
+                span.set_attribute('langfuse.observation.output', serialize_module_output(result))
+                span.set_attribute('langfuse.observation.status', 'completed')
+                span.set_attribute('dspy.status', 'completed')
+                if root_call
+                  span.set_attribute('langfuse.trace.output', serialize_module_output(result))
+                  span.set_attribute('langfuse.trace.status', 'completed')
+                end
+              end
+            end
+          rescue StandardError => e
+            if span
+              span.set_attribute('langfuse.observation.output', serialize_module_error_output(e))
+              span.set_attribute('langfuse.observation.status', 'error')
+              span.set_attribute('dspy.error.class', e.class.name)
+              span.set_attribute('dspy.error.message', e.message.to_s[0, 2000]) if e.message
+              span.set_attribute('dspy.status', 'error')
+              if root_call
+                span.set_attribute('langfuse.trace.output', serialize_module_error_output(e))
+                span.set_attribute('langfuse.trace.status', 'error')
+              end
+              if e.respond_to?(:iterations)
+                span.set_attribute('dspy.error.iterations', e.iterations.to_i) unless e.iterations.nil?
+              end
+              if e.respond_to?(:max_iterations)
+                span.set_attribute('dspy.error.max_iterations', e.max_iterations.to_i) unless e.max_iterations.nil?
+              end
+              if e.respond_to?(:tools_used)
+                span.set_attribute('dspy.error.tools_used', Array(e.tools_used).map(&:to_s))
+              end
             end
+            raise
           end
         end
       end
@@ -303,7 +346,91 @@ module DSPy
       result.to_s
     end
 
-    private :instrument_forward_call, :serialize_module_input, :serialize_module_output
+    def serialize_module_error_output(error)
+      payload = {
+        error: {
+          class: error.class.name,
+          message: error.message.to_s
+        }
+      }
+
+      if error.respond_to?(:iterations) || error.respond_to?(:max_iterations) || error.respond_to?(:tools_used)
+        payload[:react] = {}
+        payload[:react][:iterations] = error.iterations if error.respond_to?(:iterations)
+        payload[:react][:max_iterations] = error.max_iterations if error.respond_to?(:max_iterations)
+        payload[:react][:tools_used] = Array(error.tools_used) if error.respond_to?(:tools_used)
+      end
+
+      serialized = DSPy::TypeSerializer.serialize(payload)
+      JSON.generate(serialized)
+    rescue StandardError
+      "#{error.class}: #{error.message}"
+    end
+
+    def root_trace_attributes(call_args, call_kwargs, input_json)
+      metadata = {
+        module: self.class.name,
+        signature: (respond_to?(:signature_class) ? signature_class&.name : nil),
+        signature_kind: (respond_to?(:signature_class) ? infer_signature_kind(signature_class&.name) : nil),
+        predictor_label: module_scope_label
+      }.compact
+      conversation_id, conversation_id_source = resolve_conversation_id(call_args, call_kwargs)
+      metadata[:conversation_id_source] = conversation_id_source if conversation_id_source
+
+      {
+        'langfuse.trace.name' => "#{self.class.name}.forward",
+        'langfuse.trace.input' => input_json,
+        'langfuse.trace.metadata' => JSON.generate(metadata),
+        'langfuse.trace.output' => '{"status":"in_progress"}',
+        'conversation_id' => conversation_id,
+        'dspy.conversation_id' => conversation_id
+      }
+    rescue StandardError
+      {}
+    end
+
+    # Conversation ID precedence is deterministic:
+    # 1. top-level kwargs[:conversation_id]
+    # 2. first positional hash arg[:conversation_id]
+    # 3. kwargs[:input_context][:conversation_id]
+    # 4. DSPy::Context.current[:conversation_id]
+    def resolve_conversation_id(call_args, call_kwargs)
+      direct = fetch_hash_value(call_kwargs, :conversation_id)
+      return [direct.to_s, 'kwargs.conversation_id'] if present_value?(direct)
+
+      first_arg = call_args.first if call_args.is_a?(Array) && call_args.first.is_a?(Hash)
+      arg_value = fetch_hash_value(first_arg, :conversation_id)
+      return [arg_value.to_s, 'args[0].conversation_id'] if present_value?(arg_value)
+
+      input_context = fetch_hash_value(call_kwargs, :input_context)
+      nested = fetch_hash_value(input_context, :conversation_id)
+      return [nested.to_s, 'kwargs.input_context.conversation_id'] if present_value?(nested)
+
+      context_value = fetch_hash_value(DSPy::Context.current, :conversation_id)
+      return [context_value.to_s, 'context.conversation_id'] if present_value?(context_value)
+
+      [nil, nil]
+    end
+
+    def fetch_hash_value(hash, key)
+      return nil unless hash.is_a?(Hash)
+
+      hash[key] || hash[key.to_s]
+    end
+
+    def present_value?(value)
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def infer_signature_kind(signature_name)
+      return 'custom' unless signature_name
+      return 'thought' if signature_name.match?(/thought/i)
+      return 'observation' if signature_name.match?(/observation/i)
+
+      'custom'
+    end
+
+    private :instrument_forward_call, :serialize_module_input, :serialize_module_output, :serialize_module_error_output, :root_trace_attributes, :resolve_conversation_id, :fetch_hash_value, :present_value?, :infer_signature_kind
 
     sig { returns(String) }
     def module_scope_id

data/lib/dspy/predict.rb

@@ -304,7 +304,7 @@ module DSPy
         next unless prop_type
 
         # For nilable fields with nil values, ensure proper handling
-        if value.nil? && is_nilable_type?(prop_type)
+        if value.nil? && nilable_type?(prop_type)
           # For nilable fields, nil is valid - keep it as is
           next
         elsif value.nil? && prop_info[:fully_optional]

data/lib/dspy/prediction.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative 'utils/serialization'
+
 module DSPy
   class Prediction
     extend T::Sig
@@ -54,7 +56,14 @@ module DSPy
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
-      @_struct.serialize
+      hash = DSPy::Utils::Serialization.deep_serialize(@_struct.serialize)
+      hash.delete('_prediction_marker')
+      hash
+    end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args)
+      to_h.to_json(*args)
     end
 
     private

data/lib/dspy/prompt.rb

@@ -5,6 +5,7 @@ require 'sorbet-runtime'
 require 'sorbet/toon'
 
 require_relative 'few_shot_example'
+require_relative 'utils/serialization'
 require_relative 'schema/sorbet_toon_adapter'
 
 module DSPy
@@ -241,7 +242,7 @@ module DSPy
       else
         sections << "## Input Values"
         sections << "```json"
-        sections << JSON.pretty_generate(serialize_for_json(input_values))
+        sections << JSON.pretty_generate(DSPy::Utils::Serialization.deep_serialize(input_values))
         sections << "```"
         sections << ""
         sections << "Respond with the corresponding output schema fields wrapped in a ```json ``` block,"
@@ -376,51 +377,6 @@ module DSPy
       "# Please install: gem install sorbet-baml"
     end
 
-    # Recursively serialize complex objects for JSON representation
-    sig { params(obj: T.untyped).returns(T.untyped) }
-    def serialize_for_json(obj)
-      case obj
-      when T::Struct
-        # Convert T::Struct to hash using to_h method if available
-        if obj.respond_to?(:to_h)
-          serialize_for_json(obj.to_h)
-        else
-          # Fallback: serialize using struct properties
-          serialize_struct_to_hash(obj)
-        end
-      when Hash
-        # Recursively serialize hash values
-        obj.transform_values { |v| serialize_for_json(v) }
-      when Array
-        # Recursively serialize array elements
-        obj.map { |item| serialize_for_json(item) }
-      when T::Enum
-        # Serialize enums to their string representation
-        obj.serialize
-      else
-        # For basic types (String, Integer, Float, Boolean, etc.), return as-is
-        obj
-      end
-    end
-
-    # Fallback method to serialize T::Struct to hash when to_h is not available
-    sig { params(struct_obj: T::Struct).returns(T::Hash[Symbol, T.untyped]) }
-    def serialize_struct_to_hash(struct_obj)
-      result = {}
-      
-      # Use struct's props method to get all properties
-      if struct_obj.class.respond_to?(:props)
-        struct_obj.class.props.each do |prop_name, _prop_info|
-          if struct_obj.respond_to?(prop_name)
-            value = struct_obj.public_send(prop_name)
-            result[prop_name] = serialize_for_json(value)
-          end
-        end
-      end
-      
-      result
-    end
-
     def toon_data_format_enabled?
       data_format == :toon && @signature_class
     end