dspy 0.15.2 → 0.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d0e1b54d0ffe7ca9bcb7bde17b9169ee6d716eb8c7add676e6c3ac3dac6e917
-  data.tar.gz: 9b541c527a240a54a8af47aa90cefcadc4618e8787901a1ed75036a227058621
+  metadata.gz: 9cc1edc860e1ab653456abf9dbeccd8b5229b17445e666ceecff554b17427094
+  data.tar.gz: e5e595e5ff48a0f61ee6ecd1f3e537656d4b6c44d2ded5c270a7b8f040c9d6cb
 SHA512:
-  metadata.gz: e3bb79cd7637b6dfcb1af8d4697e38becd7125c70f5a3dd876efa89742225a56ddf3b82117fa1d8d712e1ccf9d732474c213683530cf8b6c76f96755a21b0adc
-  data.tar.gz: 0bf7b51392457a7f960e611343d24dd0498c2b0cd3b6486c5993c04c9e5327b16f524447028b0d768bb560865bc750d4b5d517ae695b2bc72882483d84fccf94
+  metadata.gz: 9f4ec0f3c1b3e76e7bf0420c006f4b245f74d62118560de157742a5da9f60f3c2e669c0b3d9465982aa5d6770718e685595d54d451752e23869b83e2447e8c2b
+  data.tar.gz: 4ba4df139927c765a31ab35235c9522c5d12c7052577501f588f6444c7dd9b3c03185250fad8a95ecd1083928b58142d9f772edde2b2f3fe8018e41c1c2c0320

data/README.md

@@ -184,13 +184,15 @@ DSPy.rb has rapidly evolved from experimental to production-ready:
 
 ## Roadmap - Battle-Testing Toward v1.0
 
-DSPy.rb is currently at **v0.13.0** and approaching stability. I'm focusing on real-world usage and refinement through the 0.14, 0.15+ series before committing to a stable v1.0 API.
+DSPy.rb is currently at **v0.15.2** and approaching stability. I'm focusing on real-world usage and refinement through the 0.16+ series before committing to a stable v1.0 API.
 
 **Current Focus Areas:**
-- 🚧 **Ollama Support** - Local model integration
+- ✅ **Ollama Support** - Local model integration (completed in v0.15.0)
+- ✅ **Agentic Memory** - Persistent agent state management with Memory module
+- 🚧 **Google Gemini Support** - Integration with Gemini models (#52)
 - 🚧 **Context Engineering** - Advanced prompt optimization techniques
 - 🚧 **MCP Support** - Model Context Protocol integration
-- 🚧 **Agentic Memory** - Persistent agent state management
+- 🚧 **Additional Optimizer Support** - Expanding teleprompt capabilities
 - 🚧 **Performance Optimization** - Based on production usage patterns
 
 **v1.0 Philosophy:** 

data/lib/dspy/instrumentation/event_payload_factory.rb

@@ -0,0 +1,282 @@
+# 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