dspy 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84036f6f01324f792e9de3e85fb90092747a3a021072cb65ef02d0911832dd23
-  data.tar.gz: 368240d7747e0e381e39d117061aefa55161ec99b9a2dd4813b798f854e907b2
+  metadata.gz: e82dded62b8c11ca1ac69c75d0cdffd04e9e58daa5dcb16e66d794dbc37ee49e
+  data.tar.gz: 3d58da2a9ff3d76b9e0d5960e9e6df3dc0ac120ef97c99c640f05129d9990a77
 SHA512:
-  metadata.gz: fe445ba22336550e234359eea194aa105f204332f117b44c560a9b170ec5f126192647f9edcba09a991fda1f1bcec8144239362cb95698b32b0526efd343d587
-  data.tar.gz: b47bbd52e43b765009778c110dd58a69eb75873ce1e8a17dc0fe33c388e7c7dfd8cfcb2f848b0bc81102487acba5230a47d7a001501462ea7f9c7a1b0605fc05
+  metadata.gz: e25cecdaaf81a6985a1e6cf5bd7a709efc568c89cb687a8e9bd3e593c6e41e352ffe07798275bfca44bf0f61f9b7cc8483c57978b8c56099bf0739f00573f587
+  data.tar.gz: c465fb9231b2596b155ff839047b4b1e7a92ad2e40f98f7faabbc5eaa2b632fbd566c8d3e3c0005e0196f46ca3a0b4927fc9f64aa7bd6db262b2ae0c823e4aad

data/README.md

@@ -15,6 +15,7 @@ The result? LLM applications that actually scale and don't break when you sneeze
 - **Predict** - Basic LLM completion with structured data
 - **Chain of Thought** - Step-by-step reasoning for complex problems
 - **ReAct** - Tool-using agents with basic tool integration
+- **CodeAct** - Dynamic code execution agents for programming tasks
 - **Manual Composition** - Combine multiple LLM calls into workflows
 
 **Optimization & Evaluation:**

data/lib/dspy/code_act.rb

@@ -0,0 +1,463 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require_relative 'predict'
+require_relative 'signature'
+require 'json'
+require 'stringio'
+require_relative 'instrumentation'
+require_relative 'mixins/struct_builder'
+require_relative 'mixins/instrumentation_helpers'
+
+module DSPy
+  # Define a simple struct for CodeAct history entries with proper type annotations
+  class CodeActHistoryEntry < T::Struct
+    const :step, Integer
+    prop :thought, T.nilable(String)
+    prop :ruby_code, T.nilable(String)
+    prop :execution_result, T.nilable(String)
+    prop :error_message, String
+
+    # Custom serialization to ensure compatibility with the rest of the code
+    def to_h
+      {
+        step: step,
+        thought: thought,
+        ruby_code: ruby_code,
+        execution_result: execution_result,
+        error_message: error_message
+      }.compact
+    end
+  end
+
+  # Defines the signature for Ruby code generation
+  class RubyCodeGeneration < DSPy::Signature
+    description "Generate Ruby code to solve the given task."
+
+    input do
+      const :task, String,
+        description: "The task description requiring Ruby code solution"
+      const :context, String,
+        description: "Available variables and previous results from code execution history"
+      const :history, T::Array[CodeActHistoryEntry],
+        description: "Previous thoughts and code executions with their results. Use this to understand what has been tried and what variables are available."
+    end
+
+    output do
+      const :thought, String,
+        description: "Reasoning about the approach to solve the task with Ruby code"
+      const :ruby_code, String,
+        description: "Ruby code to execute. This should be valid Ruby code that can be evaluated safely. Avoid system calls, file operations, or other potentially dangerous operations."
+      const :explanation, String,
+        description: "Brief explanation of what the code does and why this approach was chosen"
+    end
+  end
+
+  class CodeActNextStep < T::Enum
+    enums do
+      Continue = new("continue")
+      Finish = new("finish")
+    end
+  end
+
+  # Defines the signature for processing code execution results
+  class RubyCodeObservation < DSPy::Signature
+    description "Process the result of Ruby code execution and decide what to do next."
+
+    input do
+      const :task, String,
+        description: "The original task"
+      const :history, T::Array[CodeActHistoryEntry],
+        description: "Previous thoughts, code executions, and their results"
+      const :execution_result, T.nilable(String),
+        description: "The result from executing the Ruby code"
+      const :error_message, String,
+        description: "Error message if the code execution failed (empty string if no error)"
+    end
+
+    output do
+      const :observation, String,
+        description: "Analysis of the execution result and what it means for solving the task"
+      const :next_step, CodeActNextStep,
+        description: "What to do next: '#{CodeActNextStep::Continue}' to continue with more code or '#{CodeActNextStep::Finish}' if the task is complete"
+      const :final_answer, T.nilable(String),
+        description: "If next_step is 'finish', provide the final answer to the task based on the execution results"
+    end
+  end
+
+  # CodeAct Agent using Think-Code-Observe pattern
+  class CodeAct < Predict
+    extend T::Sig
+    include Mixins::StructBuilder
+    include Mixins::InstrumentationHelpers
+
+    sig { returns(T.class_of(DSPy::Signature)) }
+    attr_reader :original_signature_class
+
+    sig { returns(T.class_of(T::Struct)) }
+    attr_reader :enhanced_output_struct
+
+    sig { returns(Integer) }
+    attr_reader :max_iterations
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    attr_reader :execution_context
+
+    sig { params(signature_class: T.class_of(DSPy::Signature), max_iterations: Integer).void }
+    def initialize(signature_class, max_iterations: 10)
+      @original_signature_class = signature_class
+      @max_iterations = max_iterations
+      @execution_context = T.let({}, T::Hash[Symbol, T.untyped])
+
+      # Create code generator using Predict to preserve field descriptions
+      @code_generator = T.let(DSPy::Predict.new(RubyCodeGeneration), DSPy::Predict)
+
+      # Create observation processor using Predict to preserve field descriptions
+      @observation_processor = T.let(DSPy::Predict.new(RubyCodeObservation), DSPy::Predict)
+
+      # Create enhanced output struct with CodeAct fields
+      @enhanced_output_struct = create_enhanced_output_struct(signature_class)
+      enhanced_output_struct = @enhanced_output_struct
+
+      # Create enhanced signature class
+      enhanced_signature = Class.new(DSPy::Signature) do
+        # Set the description
+        description signature_class.description
+
+        # Use the same input struct
+        @input_struct_class = signature_class.input_struct_class
+
+        # Use the enhanced output struct with CodeAct fields
+        @output_struct_class = enhanced_output_struct
+
+        class << self
+          attr_reader :input_struct_class, :output_struct_class
+        end
+      end
+
+      # Call parent constructor with enhanced signature
+      super(enhanced_signature)
+    end
+
+    sig { params(kwargs: T.untyped).returns(T.untyped).override }
+    def forward(**kwargs)
+      lm = config.lm || DSPy.config.lm
+
+      # Instrument the entire CodeAct agent lifecycle
+      result = instrument_prediction('dspy.codeact', @original_signature_class, kwargs, {
+        max_iterations: @max_iterations
+      }) do
+        # Validate input and extract task
+        input_struct = @original_signature_class.input_struct_class.new(**kwargs)
+        task = T.cast(input_struct.serialize.values.first, String)
+
+        # Execute CodeAct reasoning loop
+        reasoning_result = execute_codeact_reasoning_loop(task)
+
+        # Create enhanced output with all CodeAct data
+        create_enhanced_result(kwargs, reasoning_result)
+      end
+
+      result
+    end
+
+    private
+
+    # Executes the main CodeAct reasoning loop (Think-Code-Observe)
+    sig { params(task: String).returns(T::Hash[Symbol, T.untyped]) }
+    def execute_codeact_reasoning_loop(task)
+      history = T.let([], T::Array[CodeActHistoryEntry])
+      final_answer = T.let(nil, T.nilable(String))
+      iterations_count = 0
+      context = ""
+
+      while should_continue_iteration?(iterations_count, final_answer)
+        iterations_count += 1
+
+        iteration_result = execute_single_iteration(
+          task, history, context, iterations_count
+        )
+
+        if iteration_result[:should_finish]
+          final_answer = iteration_result[:final_answer]
+          break
+        end
+
+        history = iteration_result[:history]
+        context = iteration_result[:context]
+      end
+
+      handle_max_iterations_if_needed(iterations_count, final_answer, history)
+
+      {
+        history: history,
+        iterations: iterations_count,
+        final_answer: final_answer || default_no_answer_message,
+        execution_context: @execution_context
+      }
+    end
+
+    # Executes a single iteration of the Think-Code-Observe loop
+    sig { params(task: String, history: T::Array[CodeActHistoryEntry], context: String, iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
+    def execute_single_iteration(task, history, context, iteration)
+      Instrumentation.instrument('dspy.codeact.iteration', {
+        iteration: iteration,
+        max_iterations: @max_iterations,
+        history_length: history.length
+      }) do
+        execution_state = execute_think_code_step(task, context, history, iteration)
+        
+        observation_decision = process_observation_and_decide_next_step(
+          task, execution_state[:history], execution_state[:execution_result], 
+          execution_state[:error_message], iteration
+        )
+
+        if observation_decision[:should_finish]
+          return { should_finish: true, final_answer: observation_decision[:final_answer] }
+        end
+
+        finalize_iteration(execution_state, iteration)
+      end
+    end
+
+    # Executes the Think-Code step: generates code and executes it
+    sig { params(task: String, context: String, history: T::Array[CodeActHistoryEntry], iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
+    def execute_think_code_step(task, context, history, iteration)
+      code_obj = @code_generator.forward(
+        task: task,
+        context: context.empty? ? "No previous context available." : context,
+        history: history
+      )
+
+      execution_result, error_message = execute_ruby_code_with_instrumentation(
+        code_obj.ruby_code, iteration
+      )
+
+      history << create_history_entry(
+        iteration, code_obj.thought, code_obj.ruby_code,
+        execution_result, error_message
+      )
+
+      {
+        history: history,
+        thought: code_obj.thought,
+        ruby_code: code_obj.ruby_code,
+        execution_result: execution_result,
+        error_message: error_message
+      }
+    end
+
+    # Finalizes iteration by updating context and emitting events
+    sig { params(execution_state: T::Hash[Symbol, T.untyped], iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
+    def finalize_iteration(execution_state, iteration)
+      new_context = build_context_from_history(execution_state[:history])
+
+      emit_iteration_complete_event(
+        iteration, execution_state[:thought], execution_state[:ruby_code],
+        execution_state[:execution_result], execution_state[:error_message]
+      )
+
+      {
+        should_finish: false,
+        history: execution_state[:history],
+        context: new_context
+      }
+    end
+
+    # Creates enhanced output struct with CodeAct-specific fields
+    sig { params(signature_class: T.class_of(DSPy::Signature)).returns(T.class_of(T::Struct)) }
+    def create_enhanced_output_struct(signature_class)
+      input_props = signature_class.input_struct_class.props
+      output_props = signature_class.output_struct_class.props
+
+      build_enhanced_struct(
+        { input: input_props, output: output_props },
+        {
+          history: [T::Array[T::Hash[Symbol, T.untyped]], "CodeAct execution history"],
+          iterations: [Integer, "Number of iterations executed"],
+          execution_context: [T::Hash[Symbol, T.untyped], "Variables and context from code execution"]
+        }
+      )
+    end
+
+    # Creates enhanced result struct
+    sig { params(input_kwargs: T::Hash[Symbol, T.untyped], reasoning_result: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+    def create_enhanced_result(input_kwargs, reasoning_result)
+      output_field_name = @original_signature_class.output_struct_class.props.keys.first
+
+      output_data = input_kwargs.merge({
+        history: reasoning_result[:history].map(&:to_h),
+        iterations: reasoning_result[:iterations],
+        execution_context: reasoning_result[:execution_context]
+      })
+      output_data[output_field_name] = reasoning_result[:final_answer]
+
+      @enhanced_output_struct.new(**output_data)
+    end
+
+    # Helper methods for CodeAct logic
+    sig { params(iterations_count: Integer, final_answer: T.nilable(String)).returns(T::Boolean) }
+    def should_continue_iteration?(iterations_count, final_answer)
+      final_answer.nil? && (@max_iterations.nil? || iterations_count < @max_iterations)
+    end
+
+    sig { params(ruby_code: String, iteration: Integer).returns([T.nilable(String), String]) }
+    def execute_ruby_code_with_instrumentation(ruby_code, iteration)
+      Instrumentation.instrument('dspy.codeact.code_execution', {
+        iteration: iteration,
+        code_length: ruby_code.length
+      }) do
+        execute_ruby_code_safely(ruby_code)
+      end
+    end
+
+    sig { params(step: Integer, thought: String, ruby_code: String, execution_result: T.nilable(String), error_message: String).returns(CodeActHistoryEntry) }
+    def create_history_entry(step, thought, ruby_code, execution_result, error_message)
+      CodeActHistoryEntry.new(
+        step: step,
+        thought: thought,
+        ruby_code: ruby_code,
+        execution_result: execution_result,
+        error_message: error_message
+      )
+    end
+
+    sig { params(task: String, history: T::Array[CodeActHistoryEntry], execution_result: T.nilable(String), error_message: String, iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
+    def process_observation_and_decide_next_step(task, history, execution_result, error_message, iteration)
+      observation_result = @observation_processor.forward(
+        task: task,
+        history: history,
+        execution_result: execution_result,
+        error_message: error_message
+      )
+
+      return { should_finish: false } unless observation_result.next_step == CodeActNextStep::Finish
+
+      final_answer = observation_result.final_answer || execution_result || "Task completed"
+
+      { should_finish: true, final_answer: final_answer }
+    end
+
+    sig { params(history: T::Array[CodeActHistoryEntry]).returns(String) }
+    def build_context_from_history(history)
+      context_parts = []
+      
+      history.each do |entry|
+        if entry.execution_result && !entry.execution_result.empty?
+          context_parts << "Step #{entry.step} result: #{entry.execution_result}"
+        end
+      end
+
+      context_parts.join("\n")
+    end
+
+    sig { params(iteration: Integer, thought: String, ruby_code: String, execution_result: T.nilable(String), error_message: T.nilable(String)).void }
+    def emit_iteration_complete_event(iteration, thought, ruby_code, execution_result, error_message)
+      Instrumentation.emit('dspy.codeact.iteration_complete', {
+        iteration: iteration,
+        thought: thought,
+        ruby_code: ruby_code,
+        execution_result: execution_result,
+        error_message: error_message,
+        success: error_message.nil?
+      })
+    end
+
+    sig { params(iterations_count: Integer, final_answer: T.nilable(String), history: T::Array[CodeActHistoryEntry]).void }
+    def handle_max_iterations_if_needed(iterations_count, final_answer, history)
+      if iterations_count >= @max_iterations && final_answer.nil?
+        Instrumentation.emit('dspy.codeact.max_iterations', {
+          iteration_count: iterations_count,
+          max_iterations: @max_iterations,
+          final_history_length: history.length
+        })
+      end
+    end
+
+    sig { returns(String) }
+    def default_no_answer_message
+      "No solution reached within #{@max_iterations} iterations"
+    end
+
+    # Safe Ruby code execution method - placeholder for now
+    sig { params(ruby_code: String).returns([T.nilable(String), String]) }
+    def execute_ruby_code_safely(ruby_code)
+      # TODO: Implement proper sandboxing in Phase 2
+      # For now, use basic eval with error handling
+      original_stdout = nil
+      captured_output = nil
+      
+      begin
+        # Capture stdout to get print/puts output
+        original_stdout = $stdout
+        captured_output = StringIO.new
+        $stdout = captured_output
+
+        result = eval(ruby_code, binding)
+        
+        # Get the captured output
+        output = captured_output.string
+        
+        # If there's captured output, use it, otherwise use the eval result
+        final_result = output.empty? ? result.to_s : output.chomp
+        
+        [final_result, ""]
+      rescue SyntaxError => e
+        [nil, "Error: #{e.message}"]
+      rescue => e
+        [nil, "Error: #{e.message}"]
+      ensure
+        $stdout = original_stdout if original_stdout
+      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 CodeAct-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?(:execution_context) && output.execution_context.is_a?(Hash)
+        raise "Missing or invalid execution_context field"
+      end
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def generate_example_output
+      # Create a base example structure
+      example = {}
+      
+      # Add CodeAct-specific example data
+      example[:history] = [
+        {
+          step: 1,
+          thought: "I need to write Ruby code to solve this task...",
+          ruby_code: "result = 2 + 2",
+          execution_result: "4",
+          error_message: nil
+        }
+      ]
+      example[:iterations] = 1
+      example[:execution_context] = { result: 4 }
+      example
+    end
+  end
+end

data/lib/dspy/instrumentation.rb

@@ -47,6 +47,13 @@ module DSPy
         n.register_event('dspy.react.iteration_complete')
         n.register_event('dspy.react.max_iterations')
         
+        # CodeAct events
+        n.register_event('dspy.codeact')
+        n.register_event('dspy.codeact.iteration')
+        n.register_event('dspy.codeact.code_execution')
+        n.register_event('dspy.codeact.iteration_complete')
+        n.register_event('dspy.codeact.max_iterations')
+        
         # Evaluation events
         n.register_event('dspy.evaluation.start')
         n.register_event('dspy.evaluation.example')
@@ -80,6 +87,14 @@ module DSPy
         n.register_event('dspy.storage.import')
         n.register_event('dspy.storage.cleanup')
         
+        # Memory compaction events
+        n.register_event('dspy.memory.compaction_check')
+        n.register_event('dspy.memory.size_compaction')
+        n.register_event('dspy.memory.age_compaction')
+        n.register_event('dspy.memory.deduplication')
+        n.register_event('dspy.memory.relevance_pruning')
+        n.register_event('dspy.memory.compaction_complete')
+        
         # Registry events
         n.register_event('dspy.registry.register_start')
         n.register_event('dspy.registry.register_complete')

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

@@ -14,6 +14,9 @@ module DSPy
         # Anthropic requires system message to be separate from messages
         system_message, user_messages = extract_system_message(normalize_messages(messages))
         
+        # Apply JSON prefilling if needed for better Claude JSON compliance
+        user_messages = prepare_messages_for_json(user_messages, system_message)
+        
         request_params = {
           model: model,
           messages: user_messages,
@@ -77,6 +80,109 @@ module DSPy
 
       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 = []

data/lib/dspy/lm.rb

@@ -139,11 +139,16 @@ module DSPy
       # Try to parse the response as JSON
       content = response.content
 
-      # Extract JSON if it's in a code block
-      if content.include?('```json')
-        content = content.split('```json').last.split('```').first.strip
-      elsif content.include?('```')
-        content = content.split('```').last.split('```').first.strip
+      # Let adapters handle their own extraction logic if available
+      if adapter && adapter.respond_to?(:extract_json_from_response, true)
+        content = adapter.send(:extract_json_from_response, content)
+      else
+        # Fallback: Extract JSON if it's in a code block (legacy behavior)
+        if content.include?('```json')
+          content = content.split('```json').last.split('```').first.strip
+        elsif content.include?('```')
+          content = content.split('```').last.split('```').first.strip
+        end
       end
 
       begin
@@ -152,8 +157,17 @@ module DSPy
         # For Sorbet signatures, just return the parsed JSON
         # The Predict will handle validation
         json_payload
-      rescue JSON::ParserError
-        raise "Failed to parse LLM response as JSON: #{content}"
+      rescue JSON::ParserError => e
+        # Enhanced error message with debugging information
+        error_details = {
+          original_content: response.content,
+          extracted_content: content,
+          provider: provider,
+          model: model
+        }
+        
+        DSPy.logger.debug("JSON parsing failed: #{error_details}")
+        raise "Failed to parse LLM response as JSON: #{e.message}. Original content length: #{response.content&.length || 0} chars"
       end
     end
   end