payloop 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4dd3be8a2eac5f3cda3b04fbc7d73d2fa6c9b4f35d640840a90f6a872e90a58
-  data.tar.gz: e348e027345bc09b1233e976c38871747410d3caccac959fc119c49143f14df4
+  metadata.gz: 0d134effe2b909cc928b4dfc80149d3c9dcde238be7630bb37dba541fa33be0a
+  data.tar.gz: ddf58b4672381d25ab90b349c6bf29391e4fe099f9e304ba20f5169d3ee6bf1c
 SHA512:
-  metadata.gz: 6d030e46f95833e825651eb0c11e23116eff4f542b10784e96aff2031892c408294115bfae3c5544f37a25b32d4435092d5b17940373f4b0968a2684657611c7
-  data.tar.gz: dc86258b883762641d561b39261bbfc0b66b494f15f5d891446e00b4d786434f5684986d01d7bfb69c989a7db54991e290656fc04b59429c1ff8dad6c034c28d
+  metadata.gz: 3b943601582c65f45f66209c6c7aa37c0041f3f961130b3fce5109f09369359d05cc2c7264ca85ffea99b067c95b7c1419d165bf11d847fb994f43a29697c4df
+  data.tar.gz: 2d4ff576bccc13c526dc80ae8ab9b2dfb72a9480f3f6c88ed261a723a217271867a3f6f88e2083f8bb5a65813362b5603e8396bd5a6c944885cbf1c4010fe963

data/CHANGELOG.md

@@ -25,3 +25,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - Corrected Payloop request payload structure as needed
+
+## [0.0.3] - 2025-10-27
+
+### Fixed
+- Correct Payloop request payload structure for Google GenAI
+
+## [0.0.4] - 2025-10-28
+
+### Fixed
+- Correct Payloop request payload structure for OpenAI streaming

data/lib/payloop/client.rb

@@ -36,12 +36,7 @@ module Payloop
     end
 
     # Set attribution for cost tracking
-    def attribution(parent_id:, parent_name: nil, subsidiary_id: nil, subsidiary_name: nil,
-                    parent_uuid: nil, subsidiary_uuid: nil)
-      # Support deprecated parameters
-      parent_id ||= parent_uuid
-      subsidiary_id ||= subsidiary_uuid
-
+    def attribution(parent_id:, parent_name: nil, subsidiary_id: nil, subsidiary_name: nil)
       attr = Attribution.new(
         parent_id: parent_id,
         parent_name: parent_name,

data/lib/payloop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Payloop
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/payloop/wrappers/base.rb

@@ -84,11 +84,62 @@ module Payloop
         collector.submit_async(payload)
       end
 
+      def payloop_merge_streaming_chunk(accumulated, chunk)
+        chunk.each do |key, value|
+          if accumulated.key?(key)
+            case accumulated[key]
+            when Hash
+              payloop_merge_streaming_chunk(accumulated[key], value) if value.is_a?(Hash)
+            when Array
+              # Concatenate arrays (matches Python SDK behavior: data[key].extend(chunk_value))
+              accumulated[key].concat(value) if value.is_a?(Array)
+            else
+              accumulated[key] = value
+            end
+          else
+            accumulated[key] = value
+          end
+        end
+        accumulated
+      end
+
+      def payloop_normalize_openai_chunk(chunk)
+        # Normalize OpenAI streaming chunks to match Python SDK format
+        # Ensure delta objects have all keys present with null values
+        return chunk unless chunk.is_a?(Hash)
+
+        if chunk["choices"].is_a?(Array)
+          chunk["choices"].each do |choice|
+            next unless choice.is_a?(Hash) && choice.key?("delta")
+
+            delta = choice["delta"]
+            if delta.is_a?(Hash)
+              # Add missing keys with nil values to match Python SDK
+              delta["role"] ||= nil unless delta.key?("role")
+              delta["content"] ||= nil unless delta.key?("content")
+              delta["refusal"] ||= nil unless delta.key?("refusal")
+              delta["tool_calls"] ||= nil unless delta.key?("tool_calls")
+              delta["function_call"] ||= nil unless delta.key?("function_call")
+            end
+          end
+        end
+
+        chunk
+      end
+
       private
 
       def extract_query(_method, _args, kwargs)
         # Deep copy to avoid mutation issues
-        deep_copy(kwargs)
+        query = deep_copy(kwargs)
+
+        # Normalize stream parameter: convert Proc to boolean true
+        # This ensures streaming requests are properly serialized to JSON
+        if query.is_a?(Hash) && query[:stream].is_a?(Proc)
+          query[:stream] = true
+        end
+
+        query
       rescue StandardError
         {}
       end
@@ -100,16 +151,49 @@ module Payloop
         when String
           { text: response }
         else
-          if response.respond_to?(:to_h)
+          # Try various serialization methods
+          if response.respond_to?(:as_json)
+            deep_copy(response.as_json)
+          elsif response.respond_to?(:to_h)
             deep_copy(response.to_h)
           elsif response.respond_to?(:to_hash)
             deep_copy(response.to_hash)
           else
-            { raw: response.to_s }
+            # Extract instance variables for objects without serialization methods
+            extract_instance_variables(response)
+          end
+        end
+      rescue StandardError => e
+        # If extraction fails, try to provide useful debug info
+        { raw: response.to_s, error: e.message }
+      end
+
+      def extract_instance_variables(obj)
+        result = {}
+        obj.instance_variables.each do |var|
+          key = var.to_s.delete("@").to_sym
+          value = obj.instance_variable_get(var)
+          result[key] = serialize_value(value)
+        end
+        result
+      end
+
+      def serialize_value(value)
+        case value
+        when Hash
+          value.transform_values { |v| serialize_value(v) }
+        when Array
+          value.map { |v| serialize_value(v) }
+        when String, Numeric, TrueClass, FalseClass, NilClass
+          value
+        else
+          # Recursively extract instance variables for nested objects
+          if value.respond_to?(:instance_variables)
+            extract_instance_variables(value)
+          else
+            value.to_s
           end
         end
-      rescue StandardError
-        { raw: response.to_s }
       end
 
       def deep_copy(obj)

data/lib/payloop/wrappers/google.rb

@@ -4,7 +4,7 @@ require_relative "constants"
 
 module Payloop
   module Wrappers
-    # Wrapper for Google GenerativeAI Ruby client
+    # Wrapper for Google GenerativeAI Ruby client (google-genai gem)
     class Google
       def initialize(config, collector)
         @config = config
@@ -17,6 +17,9 @@ module Payloop
         # Prevent double registration
         return client if client.instance_variable_defined?(:@payloop_registered)
 
+        # Patch response class after client is validated (ensures gem is loaded)
+        patch_response_class!
+
         # Store references in client instance
         client.instance_variable_set(:@payloop_config, @config)
         client.instance_variable_set(:@payloop_collector, @collector)
@@ -37,6 +40,20 @@ module Payloop
               "Client does not appear to be a valid Google GenAI client (missing models method)"
       end
 
+      # Monkey-patch the GenerateContentResponse class to include missing fields
+      def patch_response_class!
+        # Check if the constant exists and hasn't been patched yet
+        return unless defined?(::Google::Genai::Types::GenerateContentResponse)
+        return if ::Google::Genai::Types::GenerateContentResponse.instance_variable_defined?(:@_payloop_patched)
+
+        ::Google::Genai::Types::GenerateContentResponse.class_eval do
+          # Use camelCase to match Google's API response keys
+          attr_accessor :modelVersion, :usageMetadata, :responseId, :createTime
+        end
+
+        ::Google::Genai::Types::GenerateContentResponse.instance_variable_set(:@_payloop_patched, true)
+      end
+
       def wrap_generate_content_method(client)
         # Get the models resource
         models_resource = client.models

data/lib/payloop/wrappers/openai.rb

@@ -45,15 +45,38 @@ module Payloop
           define_method(:chat) do |parameters: {}|
             start_time = Time.now
 
+            # Detect streaming and wrap callback to accumulate chunks
+            streaming = parameters[:stream].is_a?(Proc)
+            accumulated_response = {} if streaming
+
+            if streaming
+              # Configure streaming to include usage (matches Python SDK behavior)
+              parameters[:stream_options] ||= {}
+              parameters[:stream_options][:include_usage] = true
+
+              user_callback = parameters[:stream]
+              parameters[:stream] = proc do |chunk, bytesize|
+                # Normalize chunk to match Python SDK format (add missing delta keys with nil)
+                normalized_chunk = payloop_normalize_openai_chunk(chunk)
+                # Accumulate chunk (merge into accumulated_response)
+                payloop_merge_streaming_chunk(accumulated_response, normalized_chunk)
+                # Call user's original callback with original chunk (don't modify user's data)
+                user_callback.call(chunk, bytesize)
+              end
+            end
+
             # Call original method
             response = original_chat(parameters: parameters)
 
+            # Use accumulated response for streaming, otherwise use returned response
+            final_response = streaming ? accumulated_response : response
+
             # Submit analytics
             payloop_submit_analytics(
               method: :chat,
               args: [],
               kwargs: parameters,
-              response: response,
+              response: final_response,
               start_time: start_time,
               end_time: Time.now,
               title: OPENAI_CLIENT_TITLE

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: payloop
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Payloop
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-25 00:00:00.000000000 Z
+date: 2025-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby