strongmind-platform-sdk 3.29.0 → 3.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 799fe97b77fb105775c8b846e6916380be6845209a5157633d832186ae81bd25
-  data.tar.gz: ee0bbab328e6e27bcf72a5e634535f9ed0ab91bb57976b94a9c1fd24fac268f1
+  metadata.gz: 47af8235ee05e3c5a4e31ac2f6ad5a4936dcfd004ce0a0eae2737cf19ca59440
+  data.tar.gz: e6814730ac3a3187e89554d7b7dd3d99b629f3833f41a72de4f332f59a769a72
 SHA512:
-  metadata.gz: 7080031758db9d9bd0894dcc2b8054df0377f1bc33a6da0ba987f7be9888c343cb0e2feb83d9d811c95114e1891ff4a62c1cde7d445333b35a5bcbf6a2b4007a
-  data.tar.gz: c8e8bb3e06b1b6808cbc02c50664921dd6850520050cf5e0191a4bc01b3e2e4357bb8d0fa4c4edd14a95db1134d351a5ca3fbd1105243eb0cfd317ac85955f80
+  metadata.gz: e47283eb744412ddd608074dd12c38433db14273eb55ba3df3c5f60737b02e687b2ecce1ad70463d01709be5c6914178512c9d416f15c403444e6bf241d0e4e6
+  data.tar.gz: 24aeba0a4181cdf7cfda05ad764c54d0348016232029e0db2fe7b4c1a0362c43c75618c14eeb3bce79b47cda9977f8f296808d499681bf327f8e2ebb2c3909a8

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [3.30.0] - 2026-05-14
+
+- Add `PlatformSdk::Observability::Langfuse::OpenAIAdapter` — wraps direct `ruby-openai` chat calls and fires `llm_call.platform_sdk` notifications with model, input messages, output content, and token usage extracted from OpenAI's response shape. Apps that hit OpenAI's API outside of RubyLLM now get the same Langfuse generation observations.
+- Add `PlatformSdk::Observability::Langfuse::BedrockClaudeAdapter` — wraps direct AWS Bedrock `invoke_model` calls for Anthropic Claude (Messages API on Bedrock). Supports both non-streaming (`with_observability`) and event-streaming (`with_streaming_observability { |collector| ... }`) modes; the streaming collector accumulates `content_block_delta` text and pulls final token counts from `message_stop`'s `amazon-bedrock-invocationMetrics`.
+- Both adapters expose `with_observability` block helpers (success/failure fires + re-raises) and a bare `fire(...)` method for after-the-fact emission. Neither adapter requires its underlying gem (`ruby-openai`, `aws-sdk-bedrockruntime`) at load time — the SDK loads cleanly without them.
+
 ## [3.29.0] - 2026-05-12
 
 - Add `PlatformSdk::Observability::Langfuse::NotificationSubscriber` — subscribes to the `llm_call.platform_sdk` `ActiveSupport::Notifications` event and forwards to `Recorder.record_generation`. Apps can instrument LLM calls without coupling to a host concern; adding a second observability backend later is one more `subscribe` call.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    strongmind-platform-sdk (3.29.0)
+    strongmind-platform-sdk (3.30.0)
       asset_sync
       aws-sdk-cloudwatch
       aws-sdk-secretsmanager (~> 1.66)
@@ -154,7 +154,7 @@ GEM
     ffi (1.17.0)
     ffi (1.17.0-x86_64-darwin)
     ffi (1.17.0-x86_64-linux-gnu)
-    fog-aws (3.33.2)
+    fog-aws (3.33.1)
       base64 (>= 0.2, < 0.4)
       fog-core (~> 2.6)
       fog-json (~> 1.1)
@@ -164,7 +164,7 @@ GEM
       excon (~> 1.0)
       formatador (>= 0.2, < 2.0)
       mime-types
-    fog-json (1.3.0)
+    fog-json (1.2.0)
       fog-core
       multi_json (~> 1.10)
     fog-xml (0.1.5)
@@ -177,12 +177,6 @@ GEM
     google-protobuf (4.33.6)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.33.6-x86_64-darwin)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.6-x86_64-linux-gnu)
-      bigdecimal
-      rake (>= 13)
     googleapis-common-protos-types (1.22.0)
       google-protobuf (~> 4.26)
     hashdiff (1.1.0)
@@ -213,7 +207,7 @@ GEM
     mime-types (3.7.0)
       logger
       mime-types-data (~> 3.2025, >= 3.2025.0507)
-    mime-types-data (3.2026.0414)
+    mime-types-data (3.2026.0317)
     mini_mime (1.1.5)
     mini_portile2 (2.8.7)
     minitest (5.24.1)
@@ -221,7 +215,7 @@ GEM
     mutex_m (0.2.0)
     net-http (0.4.1)
       uri
-    net-imap (0.6.4)
+    net-imap (0.6.3)
       date
       net-protocol
     net-pop (0.1.2)

data/lib/platform_sdk/observability/langfuse/bedrock_claude_adapter.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+require 'json'
+
+module PlatformSdk
+  module Observability
+    module Langfuse
+      # Fires `llm_call.platform_sdk` notifications for Anthropic Claude calls
+      # made directly through the AWS Bedrock SDK (rather than via RubyLLM).
+      # Two entry points cover the two Bedrock invocation modes:
+      #
+      #   # Non-streaming (`bedrock_client.invoke_model(payload)`)
+      #   PlatformSdk::Observability::Langfuse::BedrockClaudeAdapter.with_observability(
+      #     payload: { model_id: 'us.anthropic.claude-sonnet-4-6',
+      #                body: JSON.dump(anthropic_messages_payload) },
+      #     context: 'generate_outline'
+      #   ) { bedrock_client.invoke_model(payload) }
+      #
+      #   # Streaming (`bedrock_client.invoke_model_with_response_stream`)
+      #   PlatformSdk::Observability::Langfuse::BedrockClaudeAdapter.with_streaming_observability(
+      #     payload: { model_id: ..., body: JSON.dump(...) },
+      #     context: 'chat_stream'
+      #   ) do |collector|
+      #     bedrock_client.invoke_model_with_response_stream(
+      #       payload.merge(event_stream_handler: proc do |stream|
+      #         stream.on_chunk_event do |event|
+      #           collector.observe(event)
+      #           # ...the caller's own chunk handling
+      #         end
+      #       end)
+      #     )
+      #   end
+      #
+      # The streaming collector accumulates text from `content_block_delta`
+      # events and pulls the final `input_tokens`/`output_tokens` from the
+      # `message_stop` event's `amazon-bedrock-invocationMetrics`. The
+      # notification fires once after the block returns.
+      #
+      # No hard dependency on the AWS SDK — this adapter only reads the
+      # documented JSON shape of Anthropic's Messages API on Bedrock.
+      module BedrockClaudeAdapter
+        class << self
+          def with_observability(payload:, context:)
+            response = yield
+            fire(payload:, response:, context:)
+            response
+          rescue StandardError => e
+            fire(payload:, response: nil, context:, error: e)
+            raise
+          end
+
+          def with_streaming_observability(payload:, context:)
+            collector = StreamCollector.new
+            result = yield collector
+            fire_from_collector(payload:, collector:, context:)
+            result
+          rescue StandardError => e
+            fire_from_collector(payload:, collector:, context:, error: e)
+            raise
+          end
+
+          # After-the-fact emission for non-streaming calls. Caller can use
+          # this if they want to invoke Bedrock outside of the block helper
+          # and emit observability separately.
+          def fire(payload:, response:, context:, error: nil)
+            attrs = decode_response(response)
+            notify(payload:, output: attrs[:output], usage: attrs[:usage], context:, error:)
+          rescue StandardError => e
+            OpenTelemetry.handle_error(
+              message: "BedrockClaudeAdapter.fire failed: #{e.class}: #{e.message[0, 200]}"
+            )
+            nil
+          end
+
+          private
+
+          def fire_from_collector(payload:, collector:, context:, error: nil)
+            usage = collector.usage
+            notify(
+              payload:,
+              output: collector.text.empty? ? nil : collector.text,
+              usage: usage.values.any? ? usage : {},
+              context:,
+              error:
+            )
+          end
+
+          def notify(payload:, output:, usage:, context:, error:)
+            built = build_payload(payload:, output:, usage:, context:, error:)
+            return unless built
+
+            ActiveSupport::Notifications.instrument(LLM_CALL_EVENT, built)
+          rescue StandardError => e
+            OpenTelemetry.handle_error(
+              message: "BedrockClaudeAdapter.fire failed: #{e.class}: #{e.message[0, 200]}"
+            )
+            nil
+          end
+
+          def build_payload(payload:, output:, usage:, context:, error:)
+            return nil unless Langfuse.enabled?
+
+            # Tolerate non-Hash payloads (some callers pass `to_json`'d strings
+            # in tests) — extract only when the shape is what we expect.
+            payload = payload.is_a?(Hash) ? payload : {}
+            body = decode_body(payload[:body] || payload['body'])
+
+            {
+              name: context || 'llm_call',
+              model: payload[:model_id] || payload['model_id'] || body[:model] || body['model'],
+              input: body[:messages] || body['messages'],
+              output:,
+              usage: usage || {},
+              provider: 'aws.bedrock',
+              error:
+            }
+          end
+
+          def decode_body(body)
+            return body if body.is_a?(Hash)
+            return {} if body.nil?
+
+            JSON.parse(body.to_s)
+          rescue JSON::ParserError
+            {}
+          end
+
+          # Pulls `output` (concatenated text from content blocks) and `usage`
+          # (`input_tokens`/`output_tokens`) from a non-streaming Anthropic
+          # Messages-on-Bedrock response. Tolerant of both `response.body`
+          # (AWS SDK Seahorse) and plain Hash shapes for ease of testing.
+          def decode_response(response)
+            return { output: nil, usage: {} } if response.nil?
+
+            body = response.respond_to?(:body) ? response.body : response
+            # Rewind after read so the caller can re-read response.body
+            # downstream — Bedrock's Seahorse response wraps a StringIO that
+            # would otherwise be consumed by our instrumentation.
+            if body.respond_to?(:read)
+              raw = body.read
+              body.rewind if body.respond_to?(:rewind)
+              body = raw
+            end
+            parsed = body.is_a?(Hash) ? body : safe_parse_json(body.to_s)
+
+            { output: extract_text(parsed), usage: extract_usage(parsed) }
+          end
+
+          def safe_parse_json(str)
+            JSON.parse(str)
+          rescue JSON::ParserError
+            {}
+          end
+
+          def extract_text(parsed)
+            content = parsed['content'] || parsed[:content]
+            return nil unless content.is_a?(Array)
+
+            content.filter_map { |block| block['text'] || block[:text] }.join
+          end
+
+          def extract_usage(parsed)
+            usage = parsed['usage'] || parsed[:usage] || {}
+            {
+              input_tokens: usage['input_tokens'] || usage[:input_tokens],
+              output_tokens: usage['output_tokens'] || usage[:output_tokens]
+            }
+          end
+        end
+
+        # Accumulates streaming-response state so the adapter can emit a
+        # single observation after the stream ends.
+        #
+        # Bedrock's invoke_model_with_response_stream yields events whose
+        # `bytes` is JSON. For Anthropic on Bedrock the relevant event types
+        # are:
+        #
+        # * `content_block_delta` — incremental text in `delta.text`
+        # * `message_delta` — top-level `usage.output_tokens` (final count)
+        # * `message_stop` — Bedrock adds `amazon-bedrock-invocationMetrics`
+        #   here with `inputTokenCount` and `outputTokenCount`
+        #
+        # Both message_delta and message_stop are emitted on success; we
+        # prefer message_stop's metrics when both are present.
+        class StreamCollector
+          attr_reader :text
+
+          def initialize
+            @text = +''
+            @input_tokens = nil
+            @output_tokens = nil
+          end
+
+          def usage
+            { input_tokens: @input_tokens, output_tokens: @output_tokens }
+          end
+
+          def observe(event)
+            parsed = parse_event(event)
+            return if parsed.nil?
+
+            case parsed['type']
+            when 'message_start'
+              # Anthropic emits initial input_tokens here. Used as a
+              # fallback when Bedrock's message_stop invocationMetrics
+              # are absent (future models, guardrail truncations, etc.).
+              start_usage = parsed.dig('message', 'usage') || {}
+              @input_tokens ||= start_usage['input_tokens']
+            when 'content_block_delta'
+              delta_text = parsed.dig('delta', 'text')
+              @text << delta_text if delta_text
+            when 'message_delta'
+              # message_delta usage is cumulative across the (possibly many)
+              # message_delta events Anthropic emits, so the latest value
+              # wins. See https://docs.anthropic.com/en/api/messages-streaming
+              usage = parsed['usage'] || {}
+              @output_tokens = usage['output_tokens'] if usage['output_tokens']
+            when 'message_stop'
+              metrics = parsed['amazon-bedrock-invocationMetrics'] || {}
+              @input_tokens = metrics['inputTokenCount'] if metrics['inputTokenCount']
+              @output_tokens = metrics['outputTokenCount'] if metrics['outputTokenCount']
+            end
+          rescue StandardError => e
+            OpenTelemetry.handle_error(
+              message: "BedrockClaudeAdapter::StreamCollector#observe failed: #{e.class}: #{e.message[0, 200]}"
+            )
+          end
+
+          private
+
+          def parse_event(event)
+            bytes = event.respond_to?(:bytes) ? event.bytes : event
+            return nil if bytes.nil?
+
+            JSON.parse(bytes.to_s)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platform_sdk/observability/langfuse/openai_adapter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+
+module PlatformSdk
+  module Observability
+    module Langfuse
+      # Fires `llm_call.platform_sdk` ActiveSupport::Notifications events with
+      # a payload extracted from a `ruby-openai` chat call. Apps that hit
+      # OpenAI's chat completions API directly (rather than via RubyLLM) call
+      # `with_observability` to get cost, tokens, model, input, and output
+      # captured in Langfuse:
+      #
+      #   PlatformSdk::Observability::Langfuse::OpenAIAdapter.with_observability(
+      #     parameters: { model: 'gpt-4o', messages: [...], ... },
+      #     context: 'amend_json'
+      #   ) do
+      #     OpenAI::Client.new.chat(parameters: parameters)
+      #   end
+      #
+      # The block runs the actual LLM call and its return value is forwarded
+      # back to the caller. On success a generation observation is recorded
+      # with model/usage from the response. On raise a failure observation
+      # is recorded and the exception is re-raised unchanged.
+      #
+      # No hard dependency on the `ruby-openai` gem — this adapter only
+      # touches the plain-Hash response shape OpenAI's API returns.
+      module OpenAIAdapter
+        class << self
+          # Wrap an `OpenAI::Client#chat` call. Forwards the block's return
+          # value. On success: fires success notification with model/input/
+          # output/usage extracted from `parameters` and the returned response.
+          # On raise: fires failure notification with `error:` set, re-raises.
+          def with_observability(parameters:, context:)
+            response = yield
+            fire(parameters:, response:, context:)
+            response
+          rescue StandardError => e
+            fire(parameters:, response: nil, context:, error: e)
+            raise
+          end
+
+          # Fire a single `llm_call.platform_sdk` notification. Useful when
+          # the caller has already invoked OpenAI and just wants to record
+          # the observation after the fact.
+          def fire(parameters:, response:, context:, error: nil)
+            payload = build_payload(parameters:, response:, context:, error:)
+            return unless payload
+
+            ActiveSupport::Notifications.instrument(LLM_CALL_EVENT, payload)
+          rescue StandardError => e
+            OpenTelemetry.handle_error(
+              message: "OpenAIAdapter.fire failed: #{e.class}: #{e.message[0, 200]}"
+            )
+            nil
+          end
+
+          private
+
+          def build_payload(parameters:, response:, context:, error:)
+            return nil unless Langfuse.enabled?
+
+            parameters ||= {}
+            choice = response.is_a?(Hash) ? response.dig('choices', 0, 'message') : nil
+            usage = response.is_a?(Hash) ? response['usage'] : nil
+
+            {
+              name: context || 'llm_call',
+              model: parameters[:model] || parameters['model'],
+              input: parameters[:messages] || parameters['messages'],
+              output: choice && choice['content'],
+              # ruby-openai responses use prompt_tokens / completion_tokens; the
+              # input_tokens / output_tokens fallbacks cover OpenAI-compatible
+              # proxies and any future rename of those fields.
+              usage: {
+                input_tokens: usage && (usage['prompt_tokens'] || usage['input_tokens']),
+                output_tokens: usage && (usage['completion_tokens'] || usage['output_tokens'])
+              },
+              provider: 'openai',
+              error:
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platform_sdk/observability/langfuse.rb

@@ -24,6 +24,8 @@ require 'platform_sdk/observability/langfuse/traceable'
 require 'platform_sdk/observability/langfuse/sidekiq_lifecycle'
 require 'platform_sdk/observability/langfuse/notification_subscriber'
 require 'platform_sdk/observability/langfuse/ruby_llm_adapter'
+require 'platform_sdk/observability/langfuse/openai_adapter'
+require 'platform_sdk/observability/langfuse/bedrock_claude_adapter'
 
 module PlatformSdk
   module Observability

data/lib/platform_sdk/version.rb

@@ -2,7 +2,7 @@
 
 module PlatformSdk
   MAJOR = 3
-  MINOR = 29
+  MINOR = 30
   PATCH = 0
 
   VERSION = "#{PlatformSdk::MAJOR}.#{PlatformSdk::MINOR}.#{PlatformSdk::PATCH}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strongmind-platform-sdk
 version: !ruby/object:Gem::Version
-  version: 3.29.0
+  version: 3.30.0
 platform: ruby
 authors:
 - Platform Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -316,10 +316,12 @@ files:
 - lib/platform_sdk/logging/pii_formatter.rb
 - lib/platform_sdk/observability.rb
 - lib/platform_sdk/observability/langfuse.rb
+- lib/platform_sdk/observability/langfuse/bedrock_claude_adapter.rb
 - lib/platform_sdk/observability/langfuse/coercions.rb
 - lib/platform_sdk/observability/langfuse/configuration.rb
 - lib/platform_sdk/observability/langfuse/notification_subscriber.rb
 - lib/platform_sdk/observability/langfuse/null_span_exporter.rb
+- lib/platform_sdk/observability/langfuse/openai_adapter.rb
 - lib/platform_sdk/observability/langfuse/recorder.rb
 - lib/platform_sdk/observability/langfuse/ruby_llm_adapter.rb
 - lib/platform_sdk/observability/langfuse/sidekiq_lifecycle.rb