dspy 0.17.0 → 0.18.0

data/lib/dspy/teleprompt/teleprompter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
-require_relative '../instrumentation'
 require_relative '../evaluate'
 require_relative '../example'
 
@@ -313,22 +312,22 @@ module DSPy
       # Instrument optimization steps
       sig { params(step_name: String, payload: T::Hash[Symbol, T.untyped], block: T.proc.returns(T.untyped)).returns(T.untyped) }
       def instrument_step(step_name, payload = {}, &block)
-        event_name = "dspy.optimization.#{step_name}"
-        
-        Instrumentation.instrument(event_name, payload.merge({
-          teleprompter_class: self.class.name,
-          config: @config.to_h
-        }), &block)
+        DSPy::Context.with_span(
+          operation: "optimization.#{step_name}",
+          'dspy.module' => 'Teleprompter',
+          'teleprompter.class' => self.class.name,
+          'teleprompter.config' => @config.to_h,
+          **payload
+        ) do
+          yield
+        end
       end
 
       # Emit optimization events
       sig { params(event_name: String, payload: T::Hash[Symbol, T.untyped]).void }
       def emit_event(event_name, payload = {})
-        full_event_name = "dspy.optimization.#{event_name}"
-        
-        Instrumentation.emit(full_event_name, payload.merge({
-          teleprompter_class: self.class.name,
-          timestamp: Time.now.iso8601
+        DSPy.log("optimization.#{event_name}", **payload.merge({
+          'teleprompter.class': self.class.name
         }))
       end
     end

data/lib/dspy/teleprompt/utils.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
-require_relative '../instrumentation'
 require_relative '../evaluate'
 require_relative '../example'
 require_relative 'data_handler'
@@ -104,11 +103,13 @@ module DSPy
         ).returns(BootstrapResult)
       end
       def self.create_n_fewshot_demo_sets(program, trainset, config: BootstrapConfig.new, metric: nil)
-        Instrumentation.instrument('dspy.optimization.bootstrap_start', {
-          trainset_size: trainset.size,
-          max_bootstrapped_examples: config.max_bootstrapped_examples,
-          num_candidate_sets: config.num_candidate_sets
-        }) do
+        DSPy::Context.with_span(
+          operation: 'optimization.bootstrap_start',
+          'dspy.module' => 'Bootstrap',
+          'bootstrap.trainset_size' => trainset.size,
+          'bootstrap.max_examples' => config.max_bootstrapped_examples,
+          'bootstrap.num_candidate_sets' => config.num_candidate_sets
+        ) do
           # Convert to typed examples if needed
           typed_examples = ensure_typed_examples(trainset)
           
@@ -172,11 +173,13 @@ module DSPy
         ).returns(DSPy::Evaluate::BatchEvaluationResult)
       end
       def self.eval_candidate_program_minibatch(program, examples, config, metric)
-        Instrumentation.instrument('dspy.optimization.minibatch_evaluation', {
-          total_examples: examples.size,
-          minibatch_size: config.minibatch_size,
-          num_batches: (examples.size.to_f / config.minibatch_size).ceil
-        }) do
+        DSPy::Context.with_span(
+          operation: 'optimization.minibatch_evaluation',
+          'dspy.module' => 'Bootstrap',
+          'minibatch.total_examples' => examples.size,
+          'minibatch.size' => config.minibatch_size,
+          'minibatch.num_batches' => (examples.size.to_f / config.minibatch_size).ceil
+        ) do
           # Randomly sample a minibatch for evaluation
           sample_size = [config.minibatch_size, examples.size].min
           sampled_examples = examples.sample(sample_size)
@@ -340,23 +343,22 @@ module DSPy
       # Emit bootstrap completion event
       sig { params(statistics: T::Hash[Symbol, T.untyped]).void }
       def self.emit_bootstrap_complete_event(statistics)
-        Instrumentation.emit('dspy.optimization.bootstrap_complete', {
-          successful_count: statistics[:successful_count],
-          failed_count: statistics[:failed_count],
-          success_rate: statistics[:success_rate],
-          candidate_sets_created: statistics[:candidate_sets_created],
-          average_set_size: statistics[:average_set_size]
+        DSPy.log('optimization.bootstrap_complete', **{
+          'bootstrap.successful_count' => statistics[:successful_count],
+          'bootstrap.failed_count' => statistics[:failed_count],
+          'bootstrap.success_rate' => statistics[:success_rate],
+          'bootstrap.candidate_sets_created' => statistics[:candidate_sets_created],
+          'bootstrap.average_set_size' => statistics[:average_set_size]
         })
       end
 
       # Emit individual bootstrap example event
       sig { params(index: Integer, success: T::Boolean, error: T.nilable(String)).void }
       def self.emit_bootstrap_example_event(index, success, error)
-        Instrumentation.emit('dspy.optimization.bootstrap_example', {
-          example_index: index,
-          success: success,
-          error: error,
-          timestamp: Time.now.iso8601
+        DSPy.log('optimization.bootstrap_example', **{
+          'bootstrap.example_index' => index,
+          'bootstrap.success' => success,
+          'bootstrap.error' => error
         })
       end
 

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -7,18 +7,11 @@ require 'securerandom'
 require_relative 'dspy/version'
 require_relative 'dspy/errors'
 require_relative 'dspy/type_serializer'
+require_relative 'dspy/observability'
+require_relative 'dspy/context'
 
 module DSPy
   extend Dry::Configurable
-
-  # Timestamp format options for instrumentation events
-  class TimestampFormat < T::Enum
-    enums do
-      ISO8601 = new('iso8601')
-      RFC3339_NANO = new('rfc3339_nano')
-      UNIX_NANO = new('unix_nano')
-    end
-  end
   
   setting :lm
   setting :logger, default: Dry.Logger(:dspy, formatter: :string)
@@ -35,86 +28,52 @@ module DSPy
   
   # Test mode disables sleeps in retry logic
   setting :test_mode, default: false
-  
-  # Nested instrumentation configuration using proper dry-configurable syntax
-  setting :instrumentation do
-    # Core settings
-    setting :enabled, default: false
-    setting :subscribers, default: []
-    setting :sampling_rate, default: 1.0
-    setting :async_processing, default: false
-    setting :buffer_size, default: 1000
-    setting :flush_interval, default: 30
-    setting :error_reporting, default: false
-    setting :error_service, default: nil
-    setting :sampling_rules, default: {}
-    setting :timestamp_format, default: TimestampFormat::ISO8601
-
-    # Nested correlation ID configuration
-    setting :correlation_id do
-      setting :enabled, default: false
-      setting :header, default: 'X-Correlation-ID'
-      setting :generator, default: -> { SecureRandom.uuid }
-    end
-
-    # Nested logger configuration
-    setting :logger do
-      setting :level, default: :info
-      setting :include_payloads, default: true
-      setting :correlation_id, default: true
-      setting :sampling, default: {}
-      setting :sampling_conditions, default: {}
-    end
-
-    # Nested OpenTelemetry configuration
-    setting :otel do
-      setting :tracer_name, default: 'dspy-ruby'
-      setting :service_name, default: 'dspy-application'
-      setting :service_version, default: DSPy::VERSION
-      setting :endpoint, default: -> { ENV['OTEL_EXPORTER_OTLP_ENDPOINT'] }
-    end
-
-    # Nested New Relic configuration
-    setting :newrelic do
-      setting :app_name, default: 'DSPy Application'
-      setting :license_key, default: -> { ENV['NEW_RELIC_LICENSE_KEY'] }
-      setting :custom_attributes, default: {}
-    end
-
-    # Nested Langfuse configuration
-    setting :langfuse do
-      setting :public_key, default: -> { ENV['LANGFUSE_PUBLIC_KEY'] }
-      setting :secret_key, default: -> { ENV['LANGFUSE_SECRET_KEY'] }
-      setting :host, default: -> { ENV['LANGFUSE_HOST'] }
-      setting :track_tokens, default: true
-      setting :track_costs, default: true
-      setting :track_prompts, default: true
-    end
-  end
 
   def self.logger
-    config.logger
+    @logger ||= create_logger
   end
 
-  # Validation methods for instrumentation configuration
-  def self.validate_instrumentation!
-    config = self.config.instrumentation
+  def self.log(event, **attributes)
+    return unless logger
     
-    raise ArgumentError, "Sampling rate must be between 0.0 and 1.0" unless config.sampling_rate.between?(0.0, 1.0)
-    raise ArgumentError, "Buffer size must be positive" unless config.buffer_size > 0
-    raise ArgumentError, "Flush interval must be positive" unless config.flush_interval > 0
-    raise ArgumentError, "Invalid timestamp format" unless config.timestamp_format.is_a?(TimestampFormat)
+    # Merge context automatically (but don't include span_stack)
+    context = Context.current.dup
+    context.delete(:span_stack)
+    attributes = context.merge(attributes)
+    attributes[:event] = event
     
-    if config.enabled && config.subscribers.empty?
-      raise ArgumentError, "Must specify at least one subscriber when instrumentation is enabled"
-    end
+    # Use Dry::Logger's structured logging
+    logger.info(attributes)
+  end
+
+  def self.create_logger
+    env = ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+    log_output = ENV['DSPY_LOG'] # Allow override
     
-    # Validate subscribers are valid symbols
-    invalid_subscribers = config.subscribers - [:logger, :otel, :newrelic, :langfuse]
-    unless invalid_subscribers.empty?
-      raise ArgumentError, "Invalid subscribers: #{invalid_subscribers.join(', ')}"
+    case env
+    when 'test'
+      # Test: key=value format to log/test.log (or override)
+      Dry.Logger(:dspy, formatter: :string) do |config|
+        config.add_backend(stream: log_output || "log/test.log")
+      end
+    when 'development'
+      # Development: key=value format to log/development.log (or override)
+      Dry.Logger(:dspy, formatter: :string) do |config|
+        config.add_backend(stream: log_output || "log/development.log")
+      end
+    when 'production', 'staging'
+      # Production: JSON to STDOUT (or override)
+      Dry.Logger(:dspy, formatter: :json) do |config|
+        config.add_backend(stream: log_output || $stdout)
+      end
+    else
+      # Fallback: key=value to STDOUT
+      Dry.Logger(:dspy, formatter: :string) do |config|
+        config.add_backend(stream: log_output || $stdout)
+      end
     end
   end
+
 end
 
 require_relative 'dspy/module'
@@ -138,15 +97,16 @@ require_relative 'dspy/teleprompt/data_handler'
 require_relative 'dspy/propose/grounded_proposer'
 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'
 require_relative 'dspy/registry/signature_registry'
 require_relative 'dspy/registry/registry_manager'
 
+# Auto-configure observability if Langfuse env vars are present
+DSPy::Observability.configure!
+
 # LoggerSubscriber will be lazy-initialized when first accessed
 
 # Detect potential gem conflicts and warn users

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
@@ -37,20 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: dry-monitor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -149,6 +135,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
 description: The Ruby framework for programming with large language models.
 email:
 - hey@vicente.services
@@ -160,16 +174,13 @@ files:
 - lib/dspy.rb
 - lib/dspy/chain_of_thought.rb
 - lib/dspy/code_act.rb
+- lib/dspy/context.rb
 - lib/dspy/errors.rb
 - lib/dspy/evaluate.rb
 - lib/dspy/example.rb
 - lib/dspy/few_shot_example.rb
 - lib/dspy/field.rb
 - lib/dspy/image.rb
-- lib/dspy/instrumentation.rb
-- lib/dspy/instrumentation/event_payload_factory.rb
-- lib/dspy/instrumentation/event_payloads.rb
-- lib/dspy/instrumentation/token_tracker.rb
 - lib/dspy/lm.rb
 - lib/dspy/lm/adapter.rb
 - lib/dspy/lm/adapter_factory.rb
@@ -200,10 +211,10 @@ files:
 - 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
 - lib/dspy/module.rb
+- lib/dspy/observability.rb
 - lib/dspy/predict.rb
 - lib/dspy/prediction.rb
 - lib/dspy/prompt.rb
@@ -216,10 +227,6 @@ files:
 - lib/dspy/storage/program_storage.rb
 - lib/dspy/storage/storage_manager.rb
 - lib/dspy/strategy.rb
-- lib/dspy/subscribers/langfuse_subscriber.rb
-- lib/dspy/subscribers/logger_subscriber.rb
-- lib/dspy/subscribers/newrelic_subscriber.rb
-- lib/dspy/subscribers/otel_subscriber.rb
 - lib/dspy/teleprompt/data_handler.rb
 - lib/dspy/teleprompt/mipro_v2.rb
 - lib/dspy/teleprompt/simple_optimizer.rb

data/lib/dspy/instrumentation/event_payload_factory.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require_relative 'event_payloads'
-
-module DSPy
-  module Instrumentation
-    # Factory for creating typed event payloads from hash data
-    module EventPayloadFactory
-      extend T::Sig
-      extend self
-      
-      # Create appropriate event struct based on event name
-      sig { params(event_name: String, payload: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
-      def create_event(event_name, payload)
-        case event_name
-        when 'dspy.lm.request'
-          create_lm_request_event(payload)
-        when 'dspy.lm.tokens'
-          create_lm_tokens_event(payload)
-        when 'dspy.lm.response.parsed'
-          create_lm_response_parsed_event(payload)
-        when 'dspy.predict'
-          create_predict_event(payload)
-        when 'dspy.predict.validation_error'
-          create_predict_validation_error_event(payload)
-        when 'dspy.chain_of_thought'
-          create_chain_of_thought_event(payload)
-        when 'dspy.chain_of_thought.reasoning_complete'
-          create_chain_of_thought_reasoning_complete_event(payload)
-        when 'dspy.react.iteration'
-          create_react_iteration_event(payload)
-        when 'dspy.react.tool_call'
-          create_react_tool_call_event(payload)
-        when 'dspy.react.iteration_complete'
-          create_react_iteration_complete_event(payload)
-        when 'dspy.react.max_iterations'
-          create_react_max_iterations_event(payload)
-        when 'dspy.codeact.iteration'
-          create_codeact_iteration_event(payload)
-        when 'dspy.codeact.code_execution'
-          create_codeact_code_execution_event(payload)
-        else
-          # Return original payload for unhandled events
-          payload
-        end
-      end
-      
-      private
-      
-      # LM Request Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(LMRequestEvent) }
-      def create_lm_request_event(payload)
-        # Extract timestamp, handling both timestamp and timestamp_ns keys
-        timestamp = extract_timestamp(payload)
-        
-        LMRequestEvent.new(
-          timestamp: timestamp,
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          gen_ai_operation_name: payload[:gen_ai_operation_name] || 'unknown',
-          gen_ai_system: payload[:gen_ai_system] || 'unknown',
-          gen_ai_request_model: payload[:gen_ai_request_model] || 'unknown',
-          signature_class: payload[:signature_class],
-          provider: payload[:provider] || 'unknown',
-          adapter_class: payload[:adapter_class] || 'unknown',
-          input_size: payload[:input_size] || 0,
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # Helper to extract timestamp from various formats
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(String) }
-      def extract_timestamp(payload)
-        if payload[:timestamp]
-          payload[:timestamp]
-        elsif payload[:timestamp_ns]
-          # Convert nanoseconds to ISO8601 for storage in struct
-          Time.at(payload[:timestamp_ns] / 1_000_000_000.0).iso8601
-        else
-          Time.now.iso8601
-        end
-      end
-      
-      # LM Tokens Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(LMTokensEvent) }
-      def create_lm_tokens_event(payload)
-        LMTokensEvent.new(
-          timestamp: extract_timestamp(payload),
-          status: payload[:status] || 'success',
-          input_tokens: payload[:input_tokens] || 0,
-          output_tokens: payload[:output_tokens] || 0,
-          total_tokens: payload[:total_tokens] || 0,
-          gen_ai_system: payload[:gen_ai_system] || 'unknown',
-          gen_ai_request_model: payload[:gen_ai_request_model] || 'unknown',
-          signature_class: payload[:signature_class]
-        )
-      end
-      
-      # LM Response Parsed Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(LMResponseParsedEvent) }
-      def create_lm_response_parsed_event(payload)
-        LMResponseParsedEvent.new(
-          timestamp: extract_timestamp(payload),
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          signature_class: payload[:signature_class] || 'unknown',
-          provider: payload[:provider] || 'unknown',
-          success: payload[:success] || false,
-          response_length: payload[:response_length] || 0,
-          parse_type: payload[:parse_type],
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # Predict Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(PredictEvent) }
-      def create_predict_event(payload)
-        PredictEvent.new(
-          timestamp: extract_timestamp(payload),
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          signature_class: payload[:signature_class] || 'unknown',
-          module_name: payload[:module_name] || 'unknown',
-          model: payload[:model] || 'unknown',
-          provider: payload[:provider] || 'unknown',
-          input_fields: payload[:input_fields] || [],
-          input_size: payload[:input_size],
-          output_size: payload[:output_size],
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # Predict Validation Error Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(PredictValidationErrorEvent) }
-      def create_predict_validation_error_event(payload)
-        PredictValidationErrorEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          status: payload[:status] || 'error',
-          signature_class: payload[:signature_class] || 'unknown',
-          module_name: payload[:module_name] || 'unknown',
-          field_name: payload[:field_name] || 'unknown',
-          error_message: payload[:error_message] || 'unknown error',
-          retry_count: payload[:retry_count] || 0
-        )
-      end
-      
-      # Chain of Thought Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(ChainOfThoughtEvent) }
-      def create_chain_of_thought_event(payload)
-        ChainOfThoughtEvent.new(
-          timestamp: extract_timestamp(payload),
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          signature_class: payload[:signature_class] || 'unknown',
-          module_name: payload[:module_name] || 'unknown',
-          model: payload[:model] || 'unknown',
-          provider: payload[:provider] || 'unknown',
-          reasoning_length: payload[:reasoning_length],
-          answer_length: payload[:answer_length],
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # Chain of Thought Reasoning Complete Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(ChainOfThoughtReasoningCompleteEvent) }
-      def create_chain_of_thought_reasoning_complete_event(payload)
-        ChainOfThoughtReasoningCompleteEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          status: payload[:status] || 'success',
-          signature_class: payload[:signature_class] || 'unknown',
-          module_name: payload[:module_name] || 'unknown',
-          reasoning_length: payload[:reasoning_length] || 0,
-          answer_present: payload[:answer_present] || false
-        )
-      end
-      
-      # ReAct Iteration Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(ReactIterationEvent) }
-      def create_react_iteration_event(payload)
-        ReactIterationEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          iteration: payload[:iteration] || 0,
-          max_iterations: payload[:max_iterations] || 5,
-          history_length: payload[:history_length] || 0,
-          tools_used_so_far: payload[:tools_used_so_far] || [],
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # ReAct Tool Call Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(ReactToolCallEvent) }
-      def create_react_tool_call_event(payload)
-        ReactToolCallEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          iteration: payload[:iteration] || 0,
-          tool_name: payload[:tool_name] || 'unknown',
-          tool_input: payload[:tool_input],
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # ReAct Iteration Complete Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(ReactIterationCompleteEvent) }
-      def create_react_iteration_complete_event(payload)
-        ReactIterationCompleteEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          status: payload[:status] || 'success',
-          iteration: payload[:iteration] || 0,
-          thought: payload[:thought] || '',
-          action: payload[:action] || '',
-          action_input: payload[:action_input],
-          observation: payload[:observation] || '',
-          tools_used: payload[:tools_used] || []
-        )
-      end
-      
-      # ReAct Max Iterations Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(ReactMaxIterationsEvent) }
-      def create_react_max_iterations_event(payload)
-        ReactMaxIterationsEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          status: payload[:status] || 'warning',
-          iteration_count: payload[:iteration_count] || 0,
-          max_iterations: payload[:max_iterations] || 5,
-          tools_used: payload[:tools_used] || [],
-          final_history_length: payload[:final_history_length] || 0
-        )
-      end
-      
-      # CodeAct Iteration Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(CodeActIterationEvent) }
-      def create_codeact_iteration_event(payload)
-        CodeActIterationEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          iteration: payload[:iteration] || 0,
-          max_iterations: payload[:max_iterations] || 5,
-          history_length: payload[:history_length] || 0,
-          code_blocks_executed: payload[:code_blocks_executed] || 0,
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-      
-      # CodeAct Code Execution Event
-      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(CodeActCodeExecutionEvent) }
-      def create_codeact_code_execution_event(payload)
-        CodeActCodeExecutionEvent.new(
-          timestamp: payload[:timestamp] || Time.now.iso8601,
-          duration_ms: payload[:duration_ms] || 0.0,
-          cpu_time_ms: payload[:cpu_time_ms] || 0.0,
-          status: payload[:status] || 'success',
-          iteration: payload[:iteration] || 0,
-          code_type: payload[:code_type] || 'unknown',
-          code_length: payload[:code_length] || 0,
-          execution_success: payload[:execution_success] || false,
-          error_type: payload[:error_type],
-          error_message: payload[:error_message]
-        )
-      end
-    end
-  end
-end