verica-observability 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 820f96678415298ec28ca60e281ae11030e9b00430f5e3dde551dac6f631ce1a
-  data.tar.gz: 721b988d642ead26441fa349a1db35eb28033842e2c3f6ea65c6eab90152c692
+  metadata.gz: 816c57a94a8a82efc43e464165b84611981c76dc6a456eb6bd359804621beddc
+  data.tar.gz: 929106f12d8e32c03de0bd9427b9babe4cf5639c5159e31d6a7f34d3d1a32d89
 SHA512:
-  metadata.gz: ce6fb5297710557c1a0fefc1ed8189737bd14fc5a7c6dc127fbd15002315f6e0da430a92d1675533acb8defedd4fc991f55d9fe2cfc821d3b760c94d4408e073
-  data.tar.gz: f23bf257a139e816217cd75a43cfa4c4db8ba869806e3668c26f505f342304db9238144e643e7000b6e3895bfc0fda389b3e881732f8b7db133cc44714cff0ec
+  metadata.gz: e7242e9480405617939a9d4ab4109f5f1eb104046372009d100c458627b7f846987a34f59b0439a766d5b297244d4a11b46400062faf3cf72ea09b0f571e9f71
+  data.tar.gz: 832738007de7cab2d6ea750369609e0d94e08c5578477038018b7086df8cddcf93de574a0f7cabdff00f13d26d736855af5a61678f3bdbc7d9655c75eb16363b

data/README.md

@@ -108,8 +108,12 @@ true)` and the wrapper injects `stream_options: { include_usage: true }` for you
 default because the extra usage chunk arrives with an empty `choices` array that
 some caller procs may not expect.
 
-Limitation: streamed tool-call deltas (`delta.tool_calls`) are not captured in
-this pass; text output, model, and usage are.
+Tool calls are captured on both paths: a non-streamed response's
+`message.tool_calls` land on the span's output message, and streamed
+`delta.tool_calls` fragments are reassembled per index (arguments concatenated
+in arrival order). Tool-call-only turns (content null, `tool_calls` present),
+the shape of a tool-looping agent's intermediate turns, produce a span output
+too, so those turns never show an empty output in Verica.
 
 ## Use (RubyLLM)
 

data/lib/verica/ruby_openai_wrapper.rb

@@ -158,10 +158,12 @@ module Verica
       message = response.dig('choices', 0, 'message')
       return unless message.is_a?(Hash)
 
-      span.set_attribute(
-        'gen_ai.output.messages',
-        JSON.generate([{ role: message['role'].to_s, content: message['content'] }])
-      )
+      # A tool-call-only turn has content null: still emitted, with tool_calls,
+      # so the trace's output is never empty when the model DID respond.
+      output = { role: message['role'].to_s, content: message['content'] }
+      tool_calls = pinned_tool_calls(message['tool_calls'])
+      output[:tool_calls] = tool_calls unless tool_calls.empty?
+      span.set_attribute('gen_ai.output.messages', JSON.generate([output]))
     end
 
     def annotate_from_stream(span, accumulator, cfg)
@@ -176,12 +178,32 @@ module Verica
       return unless cfg&.capture_content
 
       text = accumulator.content
-      return if text.nil? || text.empty?
+      tool_calls = accumulator.tool_calls
+      return if (text.nil? || text.empty?) && tool_calls.empty?
 
-      span.set_attribute(
-        'gen_ai.output.messages',
-        JSON.generate([{ role: (accumulator.role || 'assistant').to_s, content: text }])
-      )
+      # Tool-call-only turn: no content key (matches the n8n mapper; the
+      # normalizer's flattener drops empty text either way).
+      output = { role: (accumulator.role || 'assistant').to_s }
+      output[:content] = text unless text.nil? || text.empty?
+      output[:tool_calls] = tool_calls unless tool_calls.empty?
+      span.set_attribute('gen_ai.output.messages', JSON.generate([output]))
+    end
+
+    # Reduces the API's tool_calls entries to the pinned semconv shape the
+    # Verica normalizer accepts (engine `toolCallOf`): `{function: {name,
+    # arguments}}` with `arguments` passed through as the API returned it (a
+    # JSON string). Same shape the TS/n8n producers emit. Junk entries are
+    # skipped; provider ids are not part of the pinned shape.
+    def pinned_tool_calls(raw)
+      return [] unless raw.is_a?(Array)
+
+      raw.filter_map do |entry|
+        fn = entry.is_a?(Hash) ? entry['function'] : nil
+        name = fn.is_a?(Hash) ? fn['name'] : nil
+        next unless name.is_a?(String) && !name.empty?
+
+        { function: { name: name, arguments: fn['arguments'] } }
+      end
     end
 
     def safely
@@ -192,9 +214,11 @@ module Verica
 
     # Drains a ruby-openai stream (parsed Hashes, string keys) into the pieces
     # the span needs: the joined assistant text, the first non-nil model, the
-    # assistant role from the first delta that carries one, and the usage Hash
-    # from the final chunk (present only when the caller asks for it). Tool-call
-    # deltas are intentionally ignored in this pass.
+    # assistant role from the first delta that carries one, the usage Hash from
+    # the final chunk (present only when the caller asks for it), and the
+    # reassembled tool calls. Tool-call deltas carry an `index`: id/type/
+    # function.name come from the first fragment that has them; the argument
+    # fragments concatenate in arrival order into one JSON string per index.
     class StreamAccumulator
       attr_reader :content, :model, :role, :usage
 
@@ -203,6 +227,7 @@ module Verica
         @model = nil
         @role = nil
         @usage = nil
+        @tool_call_parts = {}
       end
 
       def add(chunk)
@@ -214,10 +239,47 @@ module Verica
           @role ||= delta['role']
           fragment = delta['content']
           @content << fragment if fragment.is_a?(String)
+          add_tool_call_fragments(delta['tool_calls'])
         end
         usage = chunk['usage']
         @usage = usage if usage.is_a?(Hash)
       end
+
+      # The reassembled tool calls, ordered by index, in the pinned semconv
+      # shape (`{function: {name, arguments}}`, arguments as one JSON string).
+      # Indexes that never produced a function name are dropped.
+      def tool_calls
+        @tool_call_parts.keys.sort.filter_map do |index|
+          part = @tool_call_parts[index]
+          name = part['name']
+          next unless name.is_a?(String) && !name.empty?
+
+          { function: { name: name, arguments: part['arguments'] } }
+        end
+      end
+
+      private
+
+      def add_tool_call_fragments(fragments)
+        return unless fragments.is_a?(Array)
+
+        fragments.each do |fragment|
+          next unless fragment.is_a?(Hash)
+
+          index = fragment['index']
+          next unless index.is_a?(Integer)
+
+          part = (@tool_call_parts[index] ||= { 'arguments' => +'' })
+          part['id'] ||= fragment['id']
+          part['type'] ||= fragment['type']
+          fn = fragment['function']
+          next unless fn.is_a?(Hash)
+
+          part['name'] ||= fn['name']
+          args = fn['arguments']
+          part['arguments'] << args if args.is_a?(String)
+        end
+      end
     end
   end
 end

data/lib/verica/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Verica
-  VERSION = '0.1.6'
+  VERSION = '0.1.7'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: verica-observability
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Verica
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-05 00:00:00.000000000 Z
+date: 2026-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-exporter-otlp