crystil 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4da070c2db6a9316560e3b603975352ab4fdd1e6335b9c2deae82e164f03dd3
-  data.tar.gz: 74444bd1e835403f51152bb6e6dbabf8317f33668498137c65562e6d72881371
+  metadata.gz: 90d050805fee5db26efd12b183842cb70ff4a971bac3d8cc9a8e9a5717f0174e
+  data.tar.gz: a205e8dd09052a6f686efc427b609b8b6ceebde6c147fd54708d66350f374954
 SHA512:
-  metadata.gz: 3f6fdee56c16efdc5e5788ed3cce7714e666bff78e6d49514591e690f97dca8adab72c785d4d1ac2e8d34a308ca967096b907572d5623830f5da641723cc0d8f
-  data.tar.gz: 7b837bbb97bd54f4264b11bfe11b35b25da51225f929ce2b5d0d2e57e81c944ae273c38e64f75349c71478334bf1a221642f15882b4e3c9b3eb08414cbfec4b4
+  metadata.gz: 4ed5f37da282a51c97d8262452927ece7cdaaecf02139eeec6c1c8b84d854b435483d776e8d8c49436e3f4ced7e1ca5700b1d42ca1675e24848894531e73c17d
+  data.tar.gz: 58b439278a99afe07d4c89b63824a0b08a08e6d52b5a2555b8629b6c52afc32251b8251b8e9c3885f0738778d4473c975fa9ace9ec1451d38cdc86a3de42f63c

data/CHANGELOG.md

@@ -75,3 +75,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Default endpoints now resolve to `api.crystil.com` and `collector.crystil.com`.
 
   No API surface, method signature, or request payload changed — this release is a rename only.
+
+## [0.6.0] - 2026-09-18
+
+### Added
+- Capture Anthropic streaming calls. `messages.stream` and `messages.stream_raw` are now
+  wrapped, and their telemetry is submitted once the caller has read the stream, carrying
+  the events as the unmerged list the backend's streamed extractor reads — so a streamed
+  call reports its content and token usage instead of nothing at all. Sentinel's relevance
+  check now runs on these calls too. `messages.create` is unchanged.
+
+  A read that ends early — `break`, or any of `first` / `take` / `find` / `any?` — is
+  recorded too, carrying the events received so far. So is a read cut short by an error,
+  which reports as failed but keeps the partial content and token counts rather than
+  discarding them.
+
+### Fixed
+- Record which model a `gemini-ai` call used. That gem fixes the model on the client and puts
+  it in the request path rather than the request body, so a failed call — a local raise, a 4xx,
+  a timeout — carried no model anywhere: not in the query, and not in the response, which is
+  the error. The backend could not tell which model the call was for and quarantined the record
+  instead of storing it as the zero-cost failed call it is. The wrapper now reads the model off
+  the client and records it on the query, so failed `gemini-ai` calls report like every other
+  provider's. Successful calls are unaffected — their response already named the model.
+
+  The model is added only to the copy Crystil records, for both the analytics payload and the
+  sentinel relevance check. Your parameters are not modified and the outbound request to Google
+  is unchanged. A `model` you pass yourself is kept as-is.
+
+### Notes
+- `messages.create(stream: true)` raises `ArgumentError` in the `anthropic` gem, which is
+  why the wrapper patches the two streaming methods rather than the create path the
+  JavaScript and Python SDKs use.
+- `google-genai` (v0.1.1) still has no streaming wrapper because the gem exposes no
+  streaming method. Streamed Gemini calls through the `gemini-ai` gem were already captured.
+

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 CrystilAI
+Copyright (c) 2026 Crystil, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -37,6 +37,11 @@ no API key stored in GitHub, and **you should never run `gem push` or
 `rake release` by hand** — the release's safety checks only exist in CI, and a
 version number can never be reused on RubyGems once taken.
 
+The supported path is the **`/run-release` skill**
+([.claude/skills/run-release/SKILL.md](.claude/skills/run-release/SKILL.md)), which walks these
+steps, runs the same checks CI will run before anything irreversible happens, and stops for
+confirmation before merging and before publishing. The manual steps below are the fallback.
+
 To release version `X.Y.Z`:
 
 1. **Update the version number** in [lib/crystil/version.rb](lib/crystil/version.rb):
@@ -60,13 +65,19 @@ To release version `X.Y.Z`:
    `--target`, and pushing a tag on its own triggers nothing.
    ```bash
    gh release create vX.Y.Z --target main --title "vX.Y.Z" \
-     --notes "$(sed -n '/^## \[X.Y.Z\]/,/^## \[/p' CHANGELOG.md | sed '$d')"
+     --notes "$(awk '/^## \[X\.Y\.Z\]/{f=1;next} f&&/^## \[/{exit} f' CHANGELOG.md)"
    ```
    Pass the notes explicitly as above (or `--generate-notes` for an
    auto-generated commit summary). Don't use `--notes-from-tag` here — when gh
    creates the tag it is lightweight, so that flag falls back to the commit
    message and your notes end up reading "Merge pull request #NN".
 
+   Use the `awk` form, not `sed -n '/^## \[X.Y.Z\]/,/^## \[/p' | sed '$d'`.
+   CHANGELOG.md is oldest-first, so the version you are releasing is the last
+   section in the file; with no following `## [` to stop at, the `sed` form runs
+   to EOF and `sed '$d'` then silently eats its final line. `awk` stops at the
+   next header or EOF and drops nothing.
+
    Or use the GitHub UI: *Releases → Draft a new release*, create the tag
    `vX.Y.Z` against `main`, then **Publish release**. Saving a draft does not
    trigger anything; only publishing does.

data/lib/crystil/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crystil
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/crystil/wrappers/anthropic.rb

@@ -6,6 +6,8 @@ module Crystil
   module Wrappers
     # Wrapper for Anthropic Ruby client
     class Anthropic
+      REQUEST_OPTIONS_KEYS = [:request_options, "request_options"].freeze
+
       def initialize(config, collector, sentinel = nil)
         @config = config
         @collector = collector
@@ -30,6 +32,57 @@ module Crystil
         client
       end
 
+      # A copy of the params without `request_options`, whose `extra_headers` can hold credentials.
+      # Used for telemetry and sentinel only; the gem still gets the original.
+      def self.recorded_params(params)
+        return params unless params.is_a?(Hash)
+
+        params.reject { |key, _| REQUEST_OPTIONS_KEYS.include?(key) }
+      end
+
+      # The query as it went over the wire.
+      #
+      # The caller never passes `stream:` to `messages.stream` / `stream_raw` —
+      # the gem stores it on the parsed params before building the request — so
+      # recording it here keeps the payload honest about what was actually sent.
+      # Returns a new hash; the caller's is never mutated.
+      def self.streamed_query(params)
+        return params unless params.is_a?(Hash)
+
+        params.merge(stream: true)
+      end
+
+      # The enumerable whose events are the ones the API actually sent.
+      #
+      # `stream_raw` hands back an `Anthropic::Internal::Stream` whose own events
+      # are the raw ones, so it is watched directly.
+      #
+      # `stream` hands back a `MessageStream`, and watching *that* would record
+      # the wrong list. Its `each` yields a mix: it adds synthesized `text` /
+      # `input_json` / `thinking` events and replaces `content_block_stop` and
+      # `message_stop` with richer versions of its own. The backend needs the
+      # real `content_block_stop` to parse a tool call's accumulated JSON. Its
+      # `@raw_stream` ivar holds the untouched API stream and is read lazily (the
+      # iterator is a `chain_fused` Enumerator whose body runs on first
+      # iteration), so patching `each` on the object already sitting there is
+      # picked up when the caller starts reading.
+      #
+      # `@raw_stream` is private to the gem, and the gemspec floats across the
+      # 1.x line, so a future release could move or rename it. When that inner
+      # stream cannot be found, the `stream` path records nothing rather than
+      # falling back to the outer object: a streamed payload missing
+      # `message_start` makes the backend's extractor raise, so emitting nothing
+      # beats emitting a list it cannot read.
+      def self.raw_event_stream(stream, method_name)
+        return nil unless stream.respond_to?(:each)
+        return stream if method_name == :stream_raw
+        return nil unless stream.respond_to?(:instance_variable_defined?)
+        return nil unless stream.instance_variable_defined?(:@raw_stream)
+
+        inner = stream.instance_variable_get(:@raw_stream)
+        inner if inner.respond_to?(:each)
+      end
+
       private
 
       def validate_client!(client)
@@ -47,6 +100,17 @@ module Crystil
         messages_resource.instance_variable_set(:@crystil_collector, client.instance_variable_get(:@crystil_collector))
         messages_resource.instance_variable_set(:@crystil_sentinel, client.instance_variable_get(:@crystil_sentinel))
 
+        wrap_create_method(messages_resource)
+
+        # `messages.create(stream: true)` raises ArgumentError in this gem — it
+        # routes streaming through its own methods, which bypass `create`
+        # entirely. Wrap them only when present, so mocked clients that define
+        # just `create` still register.
+        wrap_streaming_method(messages_resource, :stream) if messages_resource.respond_to?(:stream)
+        wrap_streaming_method(messages_resource, :stream_raw) if messages_resource.respond_to?(:stream_raw)
+      end
+
+      def wrap_create_method(messages_resource)
         # Store the original create method
         original_create = messages_resource.method(:create)
 
@@ -59,7 +123,7 @@ module Crystil
           version = defined?(::Anthropic::VERSION) ? ::Anthropic::VERSION : nil
 
           # Extract parameters for sentinel and analytics
-          params = kwargs.any? ? kwargs : (args.first || {})
+          params = Crystil::Wrappers::Anthropic.recorded_params(kwargs.any? ? kwargs : (args.first || {}))
           sentinel = instance_variable_get(:@crystil_sentinel)
           sentinel&.raise_if_irrelevant!(
             title: ANTHROPIC_CLIENT_TITLE,
@@ -91,7 +155,7 @@ module Crystil
           # We don't want to send intercepts to collector
           raise e
         rescue StandardError => e
-          params = kwargs.any? ? kwargs : (args.first || {})
+          params = Crystil::Wrappers::Anthropic.recorded_params(kwargs.any? ? kwargs : (args.first || {}))
 
           crystil_submit_error_analytics(
             method: :create,
@@ -107,6 +171,78 @@ module Crystil
           raise e
         end
       end
+
+      # Wraps `messages.stream` / `messages.stream_raw`.
+      #
+      # Both return a lazy stream, so there is nothing to record when the method
+      # returns — the payload is the events, and none have arrived yet. The
+      # response is instead recorded once the caller has read the stream, as the
+      # unmerged event list the backend's streamed Anthropic extractor expects.
+      # See `Base#crystil_record_event_stream`.
+      def wrap_streaming_method(messages_resource, method_name)
+        original_method = messages_resource.method(method_name)
+
+        messages_resource.define_singleton_method(method_name) do |*args, **kwargs, &block|
+          # Include Base module methods
+          extend Base unless singleton_class.include?(Base)
+
+          start_time = Time.now
+          version = defined?(::Anthropic::VERSION) ? ::Anthropic::VERSION : nil
+
+          # Extract parameters for sentinel and analytics
+          params = Crystil::Wrappers::Anthropic.recorded_params(kwargs.any? ? kwargs : (args.first || {}))
+          sentinel = instance_variable_get(:@crystil_sentinel)
+          sentinel&.raise_if_irrelevant!(
+            title: ANTHROPIC_CLIENT_TITLE,
+            request: params,
+            version: version
+          )
+
+          # Call original method
+          stream = if kwargs.any?
+                     original_method.call(**kwargs, &block)
+                   else
+                     original_method.call(*args, &block)
+                   end
+
+          events = Crystil::Wrappers::Anthropic.raw_event_stream(stream, method_name)
+
+          if events
+            crystil_record_event_stream(
+              events,
+              closer: stream,
+              method: method_name,
+              # Copied now, not at report time, so changes the caller makes while reading don't leak in.
+              kwargs: deep_copy(Crystil::Wrappers::Anthropic.streamed_query(params)),
+              start_time: start_time,
+              title: ANTHROPIC_CLIENT_TITLE,
+              version: version
+            )
+          end
+
+          # The caller's own object, so `accumulated_message`, `text`,
+          # `until_done` and the rest of its surface keep working.
+          stream
+        rescue CrystilRequestInterceptedError => e
+          # We don't want to send intercepts to collector
+          raise e
+        rescue StandardError => e
+          params = Crystil::Wrappers::Anthropic.recorded_params(kwargs.any? ? kwargs : (args.first || {}))
+
+          crystil_submit_error_analytics(
+            method: method_name,
+            args: [],
+            kwargs: Crystil::Wrappers::Anthropic.streamed_query(params),
+            error: e,
+            start_time: start_time,
+            end_time: Time.now,
+            title: ANTHROPIC_CLIENT_TITLE,
+            version: version
+          )
+
+          raise e
+        end
+      end
     end
   end
 end

data/lib/crystil/wrappers/base.rb

@@ -2,10 +2,14 @@
 
 require "time"
 
+require_relative "event_stream"
+
 module Crystil
   module Wrappers
     # Base functionality for all provider wrappers
     module Base
+      include EventStream
+
       def crystil_wrap_method(method_name, _provider_name)
         return if method(method_name).source_location&.first&.include?("crystil")
 

data/lib/crystil/wrappers/event_stream.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "fiber"
+require "json"
+
+module Crystil
+  module Wrappers
+    # Recording a lazy event stream as the list of events the provider sent.
+    #
+    # Mixed into `Base`, so a wrapper reaches it the same way it reaches
+    # `crystil_merge_streaming_chunk`. The two are alternatives, picked by what
+    # the backend extractor for that provider reads: merge the chunks into one
+    # object for OpenAI and Groq, record the events as a list for Anthropic.
+    module EventStream
+      STREAM_CUT_SHORT_MESSAGE = "Stream read ended before the provider finished sending events"
+      STREAM_CLOSED_UNREAD_MESSAGE = "Stream closed before any events were read"
+
+      # Record a lazy event stream as the unmerged list of events the provider
+      # sent, once the caller has finished reading it.
+      #
+      # This is the counterpart to `crystil_merge_streaming_chunk` for providers
+      # whose backend extractor reads a *list*. Anthropic is one: its streamed
+      # extractor keys off `conversation.response` being a list and takes the
+      # model off `message_start`. Merging the events first would flatten them
+      # into an object with no top-level model, which the backend cannot read.
+      #
+      # The stream object is returned as-is with only its `each` replaced, so
+      # everything else the provider hung on it keeps working. Enumerable
+      # methods (`map`, `to_a`, `first`, ...) route through `each` and are
+      # recorded too; `to_enum` reads past it, so a caller using that gets an
+      # untraced call rather than a broken one.
+      #
+      # Analytics fire once per stream however many times it is iterated, and
+      # only after the read ends — never per event.
+      # `closer` is the caller's object (Anthropic's `MessageStream`, not `@raw_stream`); its `close` reports too,
+      # since the call is billed before any read.
+      def crystil_record_event_stream(stream, method:, kwargs:, start_time:, title: nil, version: nil, closer: stream)
+        return stream unless stream.respond_to?(:each)
+
+        original_each = stream.method(:each)
+        # Per stream, not per read, so a `close` after a partial read that never
+        # reached its `ensure` (external iteration via `next`) still has them.
+        events = []
+        reading_fibers = []
+        reported = false
+        claim_report = -> { reported ? false : (reported = true) }
+        recorder = self
+        report = lambda do |error|
+          recorder.crystil_report_event_stream(
+            events: events.dup, error: error, method: method, kwargs: kwargs,
+            start_time: start_time, title: title, version: version
+          )
+        end
+
+        stream.define_singleton_method(:each) do |*args, &block|
+          next original_each.call(*args, &block) if block.nil?
+
+          failure = nil
+          finished = false
+          in_caller_block = false
+          reading_fibers << Fiber.current
+
+          begin
+            result = original_each.call(*args) do |event|
+              events << Crystil::Wrappers::EventStream.crystil_event_to_data(event)
+              in_caller_block = true
+              block.call(event)
+              in_caller_block = false
+            end
+            finished = true
+            result
+          rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised; Interrupt must count as failed
+            # An error from the caller's own code is theirs, not the provider's, and its message may hold their data.
+            failure = e unless in_caller_block
+            raise e
+          ensure
+            reading_fibers.delete_at(reading_fibers.rindex(Fiber.current) || reading_fibers.size)
+            # `ensure`, not the end of the `begin` body: `break` and every
+            # Enumerable method built on it (`first`, `take`, `find`, `any?`)
+            # unwind past both the success path and the `rescue`. Reporting
+            # there would leave a caller who stops early — a cancel button, a
+            # timeout guard — with a billed call and no record of it, which is
+            # the exact failure this recorder exists to prevent.
+            # A `break`/`throw` from the caller's block is a deliberate stop; the same exit while waiting
+            # on the provider is a cut-off, e.g. `Timeout.timeout` (throws on Ruby 3.2; raises on 3.3+).
+            failure ||= Crystil::StreamError.new(STREAM_CUT_SHORT_MESSAGE) unless finished || in_caller_block
+
+            report.call(failure) if claim_report.call
+          end
+        end
+
+        crystil_route_enumerators(stream)
+        crystil_report_on_close(closer, reading_fibers, claim_report) do
+          # Closed with nothing read is a call we saw start but not finish; after a partial read it is a deliberate
+          # stop, reported like a `break`.
+          report.call(events.empty? ? Crystil::StreamError.new(STREAM_CLOSED_UNREAD_MESSAGE) : nil)
+        end
+
+        stream
+      rescue StandardError
+        # Instrumentation must never be the reason a call fails. A stream that
+        # cannot take a singleton method (frozen, or with `each` defined
+        # somewhere we cannot reach) simply goes unrecorded, the same fail-open
+        # stance sentinel and `extract_response` take.
+        stream
+      end
+
+      # Anthropic's `Internal::Stream#to_enum` hands out its inner iterator, skipping the patched `each`.
+      # Route it back through so `next`-driven reads are recorded too.
+      def crystil_route_enumerators(stream)
+        %i[to_enum enum_for].each do |name|
+          stream.define_singleton_method(name) do |meth = :each, *args, &blk|
+            ::Kernel.instance_method(:to_enum).bind(self).call(meth, *args, &blk)
+          end
+        end
+      end
+
+      # Wrap `close` so it reports when no read has. A `close` from inside the
+      # caller's own read loop is left to that read's `ensure`, which sees the whole read.
+      def crystil_report_on_close(closer, reading_fibers, claim_report, &report)
+        return unless closer.respond_to?(:close)
+
+        original_close = closer.method(:close)
+        closer.define_singleton_method(:close) do |*args, &block|
+          original_close.call(*args, &block)
+        ensure
+          report.call if !reading_fibers.include?(Fiber.current) && claim_report.call
+        end
+      end
+
+      # Submit the one payload for a finished read.
+      #
+      # The events captured are what the provider actually sent, and what it
+      # billed for, so they are kept even when the read ended early or badly —
+      # a stream cut off by a network drop still tells us the input tokens. An
+      # Anthropic event list always opens with `message_start`, so any non-empty
+      # capture is one the backend extractor can read; an empty one is not, and
+      # falls back to the plain error shape, or to sending nothing at all.
+      def crystil_report_event_stream(events:, error:, method:, kwargs:, start_time:, title: nil, version: nil)
+        response = events.empty? ? nil : events
+
+        if error
+          crystil_submit_error_analytics(
+            method: method, args: [], kwargs: kwargs, error: error,
+            start_time: start_time, end_time: Time.now,
+            title: title, version: version, response: response
+          )
+        elsif response
+          crystil_submit_analytics(
+            method: method, args: [], kwargs: kwargs, response: response,
+            start_time: start_time, end_time: Time.now, title: title, version: version
+          )
+        end
+      rescue StandardError => e
+        # This runs from the recorder's `ensure`, so anything raised here would
+        # escape the caller's `each` — failing a call that succeeded, or
+        # replacing the provider's own error with ours. Reporting is best-effort.
+        warn "Crystil: Failed to record stream analytics: #{e.message}"
+      end
+
+      # A streamed event as plain data, captured the moment it goes past.
+      #
+      # Converting here rather than at submission time is deliberate. Anthropic's
+      # `MessageStream` accumulates into the events' own nested objects as later
+      # ones arrive — `message_start`'s `message`, and each `content_block_start`'s
+      # `content_block` — so a reference held until the stream ends would report
+      # the final snapshot as though the opening events had carried it.
+      # `extract_response` also deep-copies an Array as-is, so provider objects
+      # left in the list would reach the collector unserialized.
+      #
+      # Provider event models have a shallow `to_h`; their `deep_to_h` is a real copy. Objects without
+      # one are copied through a JSON round trip, and plain Hash/Array events through Marshal.
+      def self.crystil_event_to_data(event)
+        return event if event.nil?
+        return crystil_deep_copy(event) if event.is_a?(Hash) || event.is_a?(Array)
+        return event.deep_to_h if event.respond_to?(:deep_to_h)
+
+        data = JSON.parse(JSON.generate(event))
+
+        # `JSON.generate` does not raise on an object with no JSON-aware
+        # `to_json`: `Object#to_json` emits the object's `to_s`, which parses
+        # back as a String. Anything but a Hash or Array means the round trip
+        # produced an inspect string rather than the event's data.
+        return data if data.is_a?(Hash) || data.is_a?(Array)
+
+        crystil_event_to_hash(event)
+      rescue StandardError
+        crystil_event_to_hash(event)
+      end
+
+      def self.crystil_event_to_hash(event)
+        event.respond_to?(:to_h) ? event.to_h : event
+      rescue StandardError
+        event
+      end
+
+      # Plain data that cannot be marshaled (a Proc inside, say) is kept as-is rather than dropped.
+      def self.crystil_deep_copy(data)
+        Marshal.load(Marshal.dump(data))
+      rescue StandardError
+        data
+      end
+    end
+  end
+end

data/lib/crystil/wrappers/geminiai.rb

@@ -4,8 +4,14 @@ require_relative "constants"
 
 module Crystil
   module Wrappers
-    # Wrapper for Google GenerativeAI Ruby client (gemini-ai gem version 4.3.0)
+    # Wrapper for the Google GenerativeAI Ruby client (gemini-ai gem v4.3.0).
+    # Alone among the wrappers, the recorded query carries a field the caller
+    # never sent — see `extract_model`.
     class GeminiAI
+      # Shape of the gem's `@model_address`. Anchored at the end so a path a
+      # future version builds differently reads as unknown, not as a wrong model.
+      MODEL_ADDRESS_PATTERN = %r{(?:\A|/)models/(?<model>[^/]+)\z}.freeze
+
       def initialize(config, collector, sentinel = nil)
         @config = config
         @collector = collector
@@ -31,6 +37,24 @@ module Crystil
         client
       end
 
+      # The model this client is pinned to, or nil if unreadable. The gem keeps
+      # it on the client, so a failed call names the model nowhere else.
+      def self.extract_model(client)
+        address = client.instance_variable_get(:@model_address)
+        return nil unless address.is_a?(String)
+
+        address[MODEL_ADDRESS_PATTERN, :model]
+      end
+
+      # A copy of the caller's parameters with the client's model filled in, for
+      # recording only. Their own model wins; their hash is never mutated.
+      def self.parameters_with_model(parameters, model)
+        return parameters unless parameters.is_a?(Hash) && model
+        return parameters if parameters.key?(:model) || parameters.key?("model")
+
+        parameters.merge(model: model)
+      end
+
       private
 
       def validate_client!(client)
@@ -60,10 +84,16 @@ module Crystil
             start_time = Time.now
             version = defined?(::Gemini::GEM) && ::Gemini::GEM.is_a?(Hash) ? ::Gemini::GEM[:version] : nil
 
+            # The gem pins the model to the client rather than the request, so
+            # record it alongside the caller's parameters — a failed call has no
+            # response to read it from. See GeminiAI.extract_model.
+            model = Crystil::Wrappers::GeminiAI.extract_model(self)
+            recorded_query = Crystil::Wrappers::GeminiAI.parameters_with_model(parameters, model)
+
             sentinel = instance_variable_get(:@crystil_sentinel)
             sentinel&.raise_if_irrelevant!(
               title: GOOGLE_CLIENT_TITLE,
-              request: parameters,
+              request: recorded_query,
               version: version
             )
 
@@ -74,7 +104,7 @@ module Crystil
             crystil_submit_analytics(
               method: :generate_content,
               args: [],
-              kwargs: parameters,
+              kwargs: recorded_query,
               response: response,
               start_time: start_time,
               end_time: Time.now,
@@ -90,7 +120,7 @@ module Crystil
             crystil_submit_error_analytics(
               method: :generate_content,
               args: [],
-              kwargs: parameters,
+              kwargs: recorded_query,
               error: e,
               start_time: start_time,
               end_time: Time.now,
@@ -126,10 +156,16 @@ module Crystil
             start_time = Time.now
             version = defined?(::Gemini::GEM) && ::Gemini::GEM.is_a?(Hash) ? ::Gemini::GEM[:version] : nil
 
+            # The gem pins the model to the client rather than the request, so
+            # record it alongside the caller's parameters — a failed call has no
+            # response to read it from. See GeminiAI.extract_model.
+            model = Crystil::Wrappers::GeminiAI.extract_model(self)
+            recorded_query = Crystil::Wrappers::GeminiAI.parameters_with_model(parameters, model)
+
             sentinel = instance_variable_get(:@crystil_sentinel)
             sentinel&.raise_if_irrelevant!(
               title: GOOGLE_CLIENT_TITLE,
-              request: parameters,
+              request: recorded_query,
               version: version
             )
 
@@ -140,7 +176,7 @@ module Crystil
             crystil_submit_analytics(
               method: :stream_generate_content,
               args: [],
-              kwargs: parameters,
+              kwargs: recorded_query,
               response: response,
               start_time: start_time,
               end_time: Time.now,
@@ -156,7 +192,7 @@ module Crystil
             crystil_submit_error_analytics(
               method: :stream_generate_content,
               args: [],
-              kwargs: parameters,
+              kwargs: recorded_query,
               error: e,
               start_time: start_time,
               end_time: Time.now,

data/lib/crystil/wrappers/groq.rb

@@ -10,10 +10,10 @@ module Crystil
     # OpenAI gpt-oss, Qwen, compound systems), so it sits in
     # `conversation.client.provider = "groq"` rather than `title`. `title` is
     # derived per-call from the model-ID prefix — e.g.
-    # `meta-llama/llama-4-scout-17b-16e-instruct` → `"meta-llama"`,
-    # `openai/gpt-oss-20b` → `"openai"`. Legacy un-prefixed IDs
-    # (`llama-3.1-8b-instant`, `allam-2-7b`) fall back to the first
-    # alphanumeric run (`"llama"`, `"allam"`); anything unparseable falls
+    # `meta-llama/llama-prompt-guard-2-86m` → `"meta-llama"`,
+    # `openai/gpt-oss-20b` → `"openai"`. Un-prefixed IDs
+    # (`allam-2-7b`, `whisper-large-v3`) fall back to the first
+    # alphanumeric run (`"allam"`, `"whisper"`); anything unparseable falls
     # back to `GROQ_PROVIDER` (`"groq"`). `title` is never nil.
     #
     # Unlike the JS / Python groq-sdk, the Ruby `groq` gem's `Client#chat`
@@ -65,10 +65,10 @@ module Crystil
       #
       # Rules:
       #   - String with `/`: return everything before the first `/`
-      #     (`meta-llama/llama-4-...` → `"meta-llama"`, `openai/gpt-oss-20b`
-      #     → `"openai"`).
+      #     (`meta-llama/llama-prompt-guard-2-86m` → `"meta-llama"`,
+      #     `openai/gpt-oss-20b` → `"openai"`).
       #   - String without `/`: return the first run of alphanumeric characters
-      #     (`llama-3.1-8b-instant` → `"llama"`, `allam-2-7b` → `"allam"`,
+      #     (`allam-2-7b` → `"allam"`, `whisper-large-v3` → `"whisper"`,
       #     `gpt-4o` → `"gpt"`).
       #   - Anything else (non-string, empty, unrecognized shape): return
       #     `fallback`.

data/sig/crystil/wrappers/anthropic.rbs

@@ -7,12 +7,24 @@ module Crystil
       @collector: Crystil::Collector
       @sentinel: Crystil::Sentinel?
 
+      REQUEST_OPTIONS_KEYS: Array[Symbol | String]
+
       def initialize: (Crystil::Config config, Crystil::Collector collector, ?Crystil::Sentinel? sentinel) -> void
       def register: (untyped client) -> untyped
 
+      # A copy without `request_options`; a non-Hash is handed back unchanged.
+      def self.recorded_params: (untyped params) -> untyped
+      # `untyped` in, `untyped` out: the caller's params are whatever the gem
+      # accepts, and a non-Hash is handed back unchanged.
+      def self.streamed_query: (untyped params) -> untyped
+      # nil when there is no readable event stream, so nothing is recorded.
+      def self.raw_event_stream: (untyped stream, Symbol method_name) -> untyped?
+
       private
       def validate_client!: (untyped client) -> void
       def wrap_messages_method: (untyped client) -> void
+      def wrap_create_method: (untyped messages_resource) -> void
+      def wrap_streaming_method: (untyped messages_resource, Symbol method_name) -> void
     end
   end
 end

data/sig/crystil/wrappers/base.rbs

@@ -5,9 +5,12 @@ module Crystil
     module Base
       def crystil_wrap_method: (Symbol method_name, String _provider_name) -> void
       def crystil_submit_analytics: (method: Symbol, args: Array[untyped], kwargs: Hash[Symbol, untyped], response: untyped, start_time: Time, end_time: Time, ?provider: String?, ?title: String?, ?version: String?, ?status: String, ?exception: String?) -> void
-      def crystil_submit_error_analytics: (method: Symbol, args: Array[untyped], kwargs: Hash[Symbol, untyped], error: StandardError, start_time: Time, end_time: Time, ?provider: String?, ?title: String?, ?version: String?, ?response: untyped) -> void
+      def crystil_submit_error_analytics: (method: Symbol, args: Array[untyped], kwargs: Hash[Symbol, untyped], error: Exception, start_time: Time, end_time: Time, ?provider: String?, ?title: String?, ?version: String?, ?response: untyped) -> void
       def crystil_merge_streaming_chunk: (Hash[String | Symbol, untyped] accumulated, Hash[String | Symbol, untyped] chunk) -> Hash[String | Symbol, untyped]
       def crystil_normalize_openai_chunk: (untyped chunk) -> untyped
+      # `crystil_record_event_stream` / `crystil_report_event_stream` arrive via
+      # `include EventStream`; they are declared in event_stream.rbs, not here.
+      include EventStream
 
       private
       def extract_query: (Symbol _method, Array[untyped] _args, Hash[Symbol, untyped] kwargs) -> Hash[Symbol, untyped]

data/sig/crystil/wrappers/event_stream.rbs

@@ -0,0 +1,24 @@
+# Signatures for the list-shaped streaming recorder. `untyped` throughout on
+# the stream and event surface: the objects come from whichever provider gem
+# the caller registered, and the module deliberately knows nothing about them
+# beyond `each`.
+module Crystil
+  module Wrappers
+    module EventStream
+      STREAM_CUT_SHORT_MESSAGE: String
+      STREAM_CLOSED_UNREAD_MESSAGE: String
+
+      # Returns the stream it was given, with only `each` replaced — or
+      # untouched when it cannot be patched.
+      def crystil_record_event_stream: (untyped stream, method: Symbol, kwargs: untyped, start_time: Time, ?title: String?, ?version: String?, ?closer: untyped) -> untyped
+      # Overrides `to_enum` / `enum_for` so external iteration goes through the recorded `each`.
+      def crystil_route_enumerators: (untyped stream) -> void
+      # Leaves `close` alone when the object has none.
+      def crystil_report_on_close: (untyped closer, Array[Fiber] reading_fibers, ^() -> bool claim_report) { () -> void } -> void
+      def crystil_report_event_stream: (events: Array[untyped], error: Exception?, method: Symbol, kwargs: untyped, start_time: Time, ?title: String?, ?version: String?) -> void
+      def self.crystil_event_to_data: (untyped event) -> untyped
+      def self.crystil_event_to_hash: (untyped event) -> untyped
+      def self.crystil_deep_copy: (untyped data) -> untyped
+    end
+  end
+end

data/sig/crystil/wrappers/geminiai.rbs

@@ -3,6 +3,8 @@
 module Crystil
   module Wrappers
     class GeminiAI
+      MODEL_ADDRESS_PATTERN: Regexp
+
       @config: Crystil::Config
       @collector: Crystil::Collector
       @sentinel: Crystil::Sentinel?
@@ -10,6 +12,13 @@ module Crystil
       def initialize: (Crystil::Config config, Crystil::Collector collector, ?Crystil::Sentinel? sentinel) -> void
       def register: (untyped client) -> untyped
 
+      # Returns nil when the client's @model_address is absent or unreadable.
+      def self.extract_model: (untyped client) -> String?
+
+      # Returns `parameters` unchanged when the model is unknown or already
+      # present, so the return type follows the input rather than being a Hash.
+      def self.parameters_with_model: (untyped parameters, String? model) -> untyped
+
       private
       def validate_client!: (untyped client) -> void
       def wrap_generate_content_method: (untyped client) -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crystil
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Crystil
@@ -48,6 +48,7 @@ files:
 - lib/crystil/wrappers/anthropic.rb
 - lib/crystil/wrappers/base.rb
 - lib/crystil/wrappers/constants.rb
+- lib/crystil/wrappers/event_stream.rb
 - lib/crystil/wrappers/geminiai.rb
 - lib/crystil/wrappers/google.rb
 - lib/crystil/wrappers/groq.rb
@@ -68,6 +69,7 @@ files:
 - sig/crystil/wrappers/anthropic.rbs
 - sig/crystil/wrappers/base.rbs
 - sig/crystil/wrappers/constants.rbs
+- sig/crystil/wrappers/event_stream.rbs
 - sig/crystil/wrappers/geminiai.rbs
 - sig/crystil/wrappers/google.rbs
 - sig/crystil/wrappers/groq.rbs
@@ -94,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.18
+rubygems_version: 4.0.21
 specification_version: 4
 summary: Cost visibility for AI agents
 test_files: []