ask-instrumentation 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19cf5f102f3034df0b07adff53aecdc83f605b6d8841e5b42151fec2efc5c3e9
-  data.tar.gz: 3bd3eec79a433ff520f4623dadaab51ffee38dcf78eae35edd1321e237be11f8
+  metadata.gz: fb15ee2f3cd35d3b74a3fbcaf2fa8bfa57e50dae2d23276909874a9a94cd2c2b
+  data.tar.gz: c0fcdb8b98b86ff4aef64a90afdd87e35e3ae064fcfcdb02aac34018c299eaf4
 SHA512:
-  metadata.gz: ea8eb3ba18f62c98fc3e112308039b6f38f0d96f9cadc7f46a8e01ea61c43751f92949c02868ada754d2a3ca60826fa43c78f4f49ecdfce0037a654a70e903b1
-  data.tar.gz: 17de99d0f28832e26c15b007dd2ff8e5da1d65a8ec832a78f76ed42eb5518eacd3debb9fdd4d0384636c9b37f7e136bfd20400ae45d3977dce43c21d5ceb52e6
+  metadata.gz: b84962ccb2b800356b53c0babba22866f5347f31cb24d0d3417c2e46401d08c5f957a8c4ecb4cc0d20277c527f4fa682d05afc07f84bd4bc451399588da5707d
+  data.tar.gz: 136863ebb3cd6109ad2deeeadd6e2ac311e6b08e65d02d1f26cf48d80a34430bbbdf814bde99459e1b31e3ffc050dbac8f54c5efdfb3b568ce5a865122c95b3f

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [0.2.1] - 2026-06-25
 
+### Added
+- `RuntimeAdapter` — bridges ask-runtime EventSink events to Ask::Instrumentation events with stable names (`tool.started.ask`, `tool.completed.ask`, `tool.failed.ask`, `tool.cancelled.ask`, `tool.timed_out.ask`) and uniform payload schema (tool_call_id, tool_name, session_id, turn, duration, outcome, error, event).
+- `Ask::Instrumentation.install_runtime_sink` — one-liner helper to create and return an adapter sink.
+- Opt-in, no-op safe, thread-safe. No hard dependency from ask-runtime to ask-instrumentation.
+
 ### Changed
 - Submodule tests: Chat(3t), Embedding(2t), Tool(7t). Infrastructure: rubocop, overcommit, CI matrix, gemspec, SimpleCov.
 # Changelog

data/README.md

@@ -3,11 +3,10 @@
 [![Gem Version](https://badge.fury.io/rb/ask-instrumentation.svg)](https://badge.fury.io/rb/ask-instrumentation)
 [![CI](https://github.com/ask-rb/ask-instrumentation/actions/workflows/ci.yml/badge.svg)](https://github.com/ask-rb/ask-instrumentation/actions/workflows/ci.yml)
 
-LLM observability for the ask-rb ecosystem. Emits `ActiveSupport::Notifications`
-events for chat completions, embeddings, tool calls, and image generation.
-
-Works with **any** LLM provider — not tied to a specific one. Subscribe to events
-for cost tracking, logging, analytics, or alerting.
+LLM observability for the ask-rb ecosystem. Wraps `ActiveSupport::Notifications`
+and emits events for chat completions, embeddings, tool calls, and image
+generation. Works with any LLM provider: subscribe to events for cost
+tracking, logging, analytics, or alerting.
 
 ## Installation
 
@@ -15,12 +14,6 @@ for cost tracking, logging, analytics, or alerting.
 gem "ask-instrumentation"
 ```
 
-Or install it yourself:
-
-```bash
-gem install ask-instrumentation
-```
-
 ## Quick Start
 
 ```ruby
@@ -31,14 +24,14 @@ Ask::Instrumentation.subscribe do |event|
   puts "#{event.name}: #{event.duration}ms"
 end
 
-# Instrument a chat completion
+# Instrument a block of work
 Ask::Instrumentation.instrument("chat.ask", provider: "openai", model: "gpt-4") do
   # your LLM call here
 end
 
-# Wrap with metadata context
+# Attach context to every event emitted inside the block
 Ask::Instrumentation.with_metadata(user_id: 42, session_id: "abc") do
-  Ask::Instrumentation.instrument("chat.ask", { provider: "openai", model: "gpt-4" }) do
+  Ask::Instrumentation.instrument("chat.ask", provider: "openai", model: "gpt-4") do
     # ...
   end
 end
@@ -46,231 +39,122 @@ end
 
 ## Events
 
-| Event | Payload | Description |
-|---|---|---|
-| `chat.ask` | provider, model, input_tokens, output_tokens, duration | Chat completion |
-| `chat.stream.ask` | provider, model, input_tokens, output_tokens, duration | Streaming chat |
-| `tool.ask` | provider, tool_name, tool_args, duration | Tool call |
-| `embedding.ask` | provider, model, input_tokens, duration | Embedding |
-| `image.ask` | provider, model, size, duration | Image generation |
-
-## Examples
-
-### Cost Tracking
-
-Subscribe to chat events and sum model costs:
+| Event | Description |
+|---|---|
+| `chat.ask` | Chat completion |
+| `chat.stream.ask` | Streaming chat |
+| `tool.ask` | Tool execution |
+| `embedding.ask` | Embedding generation |
+| `image.ask` | Image generation |
+| `tool_call.ask` | LLM requested a tool call |
+| `tool_result.ask` | Tool call result (or error) |
+| `tool.started.ask` | Runtime tool execution started |
+| `tool.completed.ask` | Runtime tool execution completed |
+| `tool.failed.ask` | Runtime tool execution failed |
+| `tool.cancelled.ask` | Runtime tool execution cancelled |
+| `tool.timed_out.ask` | Runtime tool execution timed out |
+
+Event payloads carry provider, model, and token counts when available, plus
+any metadata set with `with_metadata`.
+
+## Essential API
+
+| Entry point | Purpose |
+|---|---|
+| `Ask::Instrumentation.subscribe(pattern = /\.ask$/, &block)` | Subscribe to matching events; returns a subscriber for `unsubscribe` |
+| `Ask::Instrumentation.unsubscribe(subscriber_or_pattern)` | Remove a subscriber |
+| `Ask::Instrumentation.instrument(name, payload = {}) { }` | Emit an event, timing the block and passing through its return value |
+| `Ask::Instrumentation.with_metadata(hash) { }` | Thread-local metadata merged into all events emitted inside the block |
+| `Ask::Instrumentation.current_metadata` | Current thread's metadata hash |
+
+Metadata lives in `Thread.current`, so concurrent threads each carry their own
+context. Nested `with_metadata` calls merge, with inner values taking
+precedence.
+
+## Runtime Adapter
+
+The `RuntimeAdapter` bridges [ask-runtime](https://github.com/ask-rb/ask-runtime)
+tool lifecycle events to Ask::Instrumentation events. This lets you observe
+tool execution through the same instrumentation pipeline as LLM calls.
 
 ```ruby
 require "ask/instrumentation"
+require "ask/instrumentation/runtime_adapter"
 
-COST_PER_TOKEN = {
-  "gpt-4"        => { input: 0.03 / 1000, output: 0.06 / 1000 },
-  "gpt-3.5-turbo" => { input: 0.001 / 1000, output: 0.002 / 1000 },
-  "claude-3-opus" => { input: 0.015 / 1000, output: 0.075 / 1000 }
-}.freeze
-
-total_cost = 0.0
-
-Ask::Instrumentation.subscribe(/chat\.ask/) do |event|
-  payload = event.payload
-  model   = payload[:model]
-  pricing = COST_PER_TOKEN[model]
-  next unless pricing
-
-  cost = (payload[:input_tokens].to_i * pricing[:input]) +
-         (payload[:output_tokens].to_i * pricing[:output])
-  total_cost += cost
-
-  puts "[COST] #{model}: $%.6f (total: $%.4f)" % [cost, total_cost]
-end
-
-# Later, in your application code:
-Ask::Instrumentation.with_metadata(session_id: "sess_123") do
-  Ask::Instrumentation.instrument("chat.ask",
-    provider: "openai",
-    model: "gpt-4",
-    input_tokens: 150,
-    output_tokens: 50
-  ) do
-    # actual LLM API call
-  end
-end
-```
-
-### Request Logging
+# One-liner: creates a sink that forwards events to Ask::Instrumentation
+sink = Ask::Instrumentation.install_runtime_sink
 
-Log all LLM events to a file with structured data:
-
-```ruby
-require "ask/instrumentation"
-require "logger"
-
-logger = Logger.new("log/llm.log")
+# Wire into an execution context
+ctx = Ask::Runtime::ExecutionContext.new(
+  session_id: "s_001", turn: 1, event_sink: sink
+)
 
+# Subscribe to the forwarded events
 Ask::Instrumentation.subscribe do |event|
-  logger.info({
-    event:    event.name,
-    duration: event.duration.round(2),
-    **event.payload
-  }.to_json)
-end
-```
-
-### Usage Analytics with Metadata
-
-Track per-user and per-session usage:
-
-```ruby
-require "ask/instrumentation"
-
-# In your application (e.g., a Rails controller):
-class ChatController < ApplicationController
-  def create
-    Ask::Instrumentation.with_metadata(
-      user_id:    current_user.id,
-      session_id: request.session.id,
-      request_id: request.request_id
-    ) do
-      # All events emitted here automatically include user/session context
-      response = llm_client.chat(params[:message])
-      render json: response
-    end
+  case event.name
+  when "tool.started.ask"
+    puts "Tool started: #{event.payload[:tool_name]}"
+  when "tool.completed.ask"
+    puts "Tool #{event.payload[:tool_name]} completed in #{event.payload[:duration]}s"
+  when "tool.failed.ask"
+    puts "Tool #{event.payload[:tool_name]} failed: #{event.payload[:error]}"
   end
 end
-
-# In a monitoring background worker:
-Ask::Instrumentation.subscribe(/chat\.ask/) do |event|
-  payload = event.payload
-  UsageReport.increment(
-    user_id:    payload[:user_id],
-    model:      payload[:model],
-    tokens_in:  payload[:input_tokens],
-    tokens_out: payload[:output_tokens]
-  )
-end
 ```
 
-### Integration with ask-llm-providers
+### Event Mapping
 
-When using the ask-rb ecosystem, providers emit events automatically:
+| Runtime EventSink type | Ask::Instrumentation event |
+|---|---|
+| `:tool_started` | `tool.started.ask` |
+| `:tool_completed` | `tool.completed.ask` |
+| `:tool_failed` | `tool.failed.ask` |
+| `:tool_cancelled` | `tool.cancelled.ask` |
+| `:tool_timed_out` | `tool.timed_out.ask` |
 
-```ruby
-require "ask/provider"
+### Payload Schema
 
-# Events are emitted automatically — no manual instrumentation needed.
-provider = Ask::Provider.for(:openai)
-provider.complete(prompt: "Hello!") # emits chat.ask
-
-# Subscribe to track everything:
-Ask::Instrumentation.subscribe do |event|
-  puts "[#{event.name}] #{event.payload[:model]} (#{event.duration}ms)"
-end
-```
+Every forwarded event includes:
 
-### With Your Own Provider
-
-You can emit events from any custom provider:
-
-```ruby
-class MyCustomProvider
-  def complete(prompt)
-    Ask::Instrumentation.instrument("chat.ask",
-      provider: "my_custom",
-      model: "my-model-v1",
-      input_tokens: prompt.length / 4
-    ) do
-      response = call_api(prompt)
-      # enrich payload after the call by returning a hash from the block?
-      # No — use with_metadata or include everything upfront.
-      response
-    end
-  end
-end
-```
-
-## API
-
-### `.subscribe(pattern = /\.ask$/, &block)`
-
-Subscribe to ask events. Accepts an optional pattern (defaults to all `.ask` events).
-
-```ruby
-# All ask events
-Ask::Instrumentation.subscribe { |event| ... }
-
-# Only chat events
-Ask::Instrumentation.subscribe(/chat\.ask/) { |event| ... }
-```
-
-### `.unsubscribe(subscriber_or_name)`
-
-Remove a subscriber by passing the object returned from `subscribe` or a string/regexp.
-
-```ruby
-subscriber = Ask::Instrumentation.subscribe { |e| ... }
-Ask::Instrumentation.unsubscribe(subscriber)
-```
-
-### `.instrument(name, payload = {}, &block)`
-
-Emit an event. The block is instrumented and its return value is passed through.
-Metadata from `with_metadata` is automatically merged into the payload.
-
-```ruby
-result = Ask::Instrumentation.instrument("chat.ask",
-  provider: "openai",
-  model: "gpt-4"
-) do
-  llm_call
-end
-```
-
-### `.with_metadata(hash, &block)`
+| Key | Type | Description |
+|---|---|---|
+| `tool_call_id` | String | Unique tool-call identifier |
+| `tool_name` | String | The tool being executed |
+| `session_id` | String, nil | Session correlation |
+| `turn` | Integer, nil | Turn number |
+| `duration` | Float, nil | Seconds (nil for `tool.started.ask`) |
+| `outcome` | String, nil | `"success"`, `"failure"`, `"cancelled"`, `"timed_out"`, or nil |
+| `error` | String, nil | Error message (failures and cancellations) |
+| `event` | Object | The original runtime event object |
 
-Set thread-local metadata that is merged into all events emitted inside the block.
-Nested blocks merge inner metadata into outer, with inner values taking precedence.
+### Lifecycle
 
 ```ruby
-Ask::Instrumentation.with_metadata(user_id: 42) do
-  Ask::Instrumentation.instrument("chat.ask", provider: "openai", model: "gpt-4") do
-    # event payload includes user_id: 42
-  end
-end
+adapter = Ask::Instrumentation::RuntimeAdapter.new
+sink = adapter.sink        # use this as your EventSink
+adapter.subscribed?        # => true
+adapter.unsubscribe        # stop forwarding events
+adapter.subscribed?        # => false
 ```
 
-### `.current_metadata`
+### Dependencies
 
-Return the current thread's metadata hash (empty hash if no metadata is set).
+The adapter requires `ask-runtime` at runtime. If `ask-runtime` is not
+available, `install_runtime_sink` returns `Ask::Runtime::EventSink.null`
+(a no-op sink). The adapter is fully opt-in and creates no hard dependency
+from ask-runtime to ask-instrumentation.
 
-```ruby
-Ask::Instrumentation.current_metadata # => {}
-```
+## Full documentation
 
-## Thread Safety
-
-All metadata is stored in `Thread.current`, making it safe to use in concurrent
-environments. Each thread has its own metadata context:
-
-```ruby
-Ask::Instrumentation.with_metadata(thread: "main") do
-  Thread.new do
-    # This thread has its own metadata context
-    Ask::Instrumentation.current_metadata # => {}
-    Ask::Instrumentation.with_metadata(thread: "worker") do
-      # ...
-    end
-  end.join
-end
-```
+The full ask-rb documentation lives at https://ask-rb.github.io/ask-docs.
+https://ask-rb.github.io/ask-docs/production/observability covers
+ask-instrumentation in depth. API reference:
+https://ask-rb.github.io/ask-docs/reference/api.
 
 ## Development
 
-```bash
-git clone https://github.com/ask-rb/ask-instrumentation.git
-cd ask-instrumentation
 bundle install
 bundle exec rake test
-```
 
 ## License
 

data/lib/ask/instrumentation/runtime_adapter.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "ask/instrumentation"
+
+module Ask
+  module Instrumentation
+    # Subscribes to an Ask::Runtime::EventSink and re-emits events through
+    # Ask::Instrumentation (ActiveSupport::Notifications) with stable names
+    # and a uniform payload schema.
+    #
+    # This is an opt-in adapter: it creates an EventSink that proxies
+    # runtime lifecycle events to the instrumentation layer so that
+    # existing subscribers (logging, analytics, cost tracking) receive
+    # tool execution events without coupling to ask-runtime internals.
+    #
+    # == Event Mapping
+    #
+    #   Runtime EventSink type   →   Ask::Instrumentation event name
+    #   ─────────────────────────     ──────────────────────────────
+    #   :tool_started            →   "tool.started.ask"
+    #   :tool_completed          →   "tool.completed.ask"
+    #   :tool_failed             →   "tool.failed.ask"
+    #   :tool_cancelled          →   "tool.cancelled.ask"
+    #   :tool_timed_out          →   "tool.timed_out.ask"
+    #
+    # == Payload Schema
+    #
+    # Every emitted event includes:
+    #
+    #   tool_call_id  [String]  — unique tool-call identifier
+    #   tool_name     [String]  — the tool being executed
+    #   session_id    [String, nil]  — session correlation
+    #   turn          [Integer, nil] — turn number
+    #   duration      [Float, nil]   — seconds (nil for ToolStarted)
+    #   outcome       [String]       — "success" | "failure" | "cancelled" | "timed_out" | nil (started)
+    #   error         [String, nil]  — error message (terminal failures only)
+    #   event         [Object]       — the original runtime event object
+    #
+    # == Usage
+    #
+    #   require "ask/instrumentation"
+    #   require "ask/instrumentation/runtime_adapter"
+    #
+    #   # One-liner: creates and returns the adapter sink
+    #   sink = Ask::Instrumentation.install_runtime_sink
+    #
+    #   # Or build explicitly
+    #   adapter = Ask::Instrumentation::RuntimeAdapter.new
+    #   sink = adapter.sink
+    #
+    #   # Wire into an execution context
+    #   ctx = Ask::Runtime::ExecutionContext.new(
+    #     session_id: "s_001", turn: 1, event_sink: sink
+    #   )
+    #
+    #   # Later, unsubscribe to stop forwarding
+    #   adapter.unsubscribe
+    #
+    # == Thread Safety
+    #
+    # The adapter is thread-safe. The underlying EventSink uses a mutex
+    # for listener management, and Ask::Instrumentation delegates to
+    # ActiveSupport::Notifications which is also thread-safe.
+    #
+    # == No-Op Safe
+    #
+    # If ask-runtime is not loaded, install_runtime_sink returns an
+    # Ask::Runtime::EventSink.null that discards all events.
+    #
+    class RuntimeAdapter
+      RUNTIME_EVENT_MAP = {
+        tool_started: "tool.started.ask",
+        tool_completed: "tool.completed.ask",
+        tool_failed: "tool.failed.ask",
+        tool_cancelled: "tool.cancelled.ask",
+        tool_timed_out: "tool.timed_out.ask"
+      }.freeze
+
+      attr_reader :sink
+
+      def initialize
+        require "ask/runtime"
+        @sink = Ask::Runtime::EventSink.new
+        @forwarding = true
+        @mutex = Mutex.new
+        subscribe_all
+      end
+
+      # Stop forwarding events to Ask::Instrumentation. The sink continues
+      # to exist but events are silently dropped.
+      def unsubscribe
+        @mutex.synchronize { @forwarding = false }
+      end
+
+      # Whether the adapter is currently forwarding events.
+      def subscribed?
+        @mutex.synchronize { @forwarding }
+      end
+
+      private
+
+      def subscribe_all
+        RUNTIME_EVENT_MAP.each do |runtime_type, instrumentation_name|
+          @sink.on(runtime_type) do |payload|
+            next unless @mutex.synchronize { @forwarding }
+
+            forward_event(instrumentation_name, payload)
+          end
+        end
+      end
+
+      def forward_event(name, payload)
+        runtime_event = payload[:event]
+        return unless runtime_event
+
+        instrument_payload = build_payload(runtime_event)
+        Ask::Instrumentation.instrument(name, instrument_payload)
+      rescue => e
+        # Never let adapter errors break the runtime event pipeline.
+        $stderr.puts "[ask-instrumentation] RuntimeAdapter error: #{e.message}" if $DEBUG
+      end
+
+      def build_payload(runtime_event)
+        base = {
+          tool_call_id: runtime_event.tool_call_id,
+          tool_name: runtime_event.tool_name,
+          session_id: runtime_event.execution_context&.session_id,
+          turn: runtime_event.execution_context&.turn,
+          event: runtime_event
+        }
+
+        # Add duration for terminal events (all except ToolStarted).
+        if runtime_event.respond_to?(:duration)
+          base[:duration] = runtime_event.duration
+        end
+
+        # Classify outcome.
+        base[:outcome] = classify_outcome(runtime_event)
+
+        # Attach error for failures.
+        if runtime_event.respond_to?(:error)
+          base[:error] = runtime_event.error
+        elsif runtime_event.respond_to?(:reason)
+          base[:error] = runtime_event.reason
+        end
+
+        base
+      end
+
+      def classify_outcome(runtime_event)
+        case runtime_event
+        when Ask::Runtime::Events::ToolStarted
+          nil
+        when Ask::Runtime::Events::ToolCompleted
+          "success"
+        when Ask::Runtime::Events::ToolFailed
+          "failure"
+        when Ask::Runtime::Events::ToolCancelled
+          "cancelled"
+        when Ask::Runtime::Events::ToolTimedOut
+          "timed_out"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ask/instrumentation/tool.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "fileutils"
+require "time" # Time#iso8601 for trace log timestamps
 
 module Ask
   module Instrumentation

data/lib/ask/instrumentation/version.rb

@@ -1,5 +1,5 @@
 module Ask
   module Instrumentation
-    VERSION = "0.2.1"
+    VERSION = "0.2.2"
   end
 end

data/lib/ask/instrumentation.rb

@@ -48,6 +48,7 @@ module Ask
     autoload :Chat, "ask/instrumentation/chat"
     autoload :Embedding, "ask/instrumentation/embedding"
     autoload :Tool, "ask/instrumentation/tool"
+    autoload :RuntimeAdapter, "ask/instrumentation/runtime_adapter"
 
     class << self
       # Subscribe to ask instrumentation events.
@@ -158,6 +159,33 @@ module Ask
       def current_metadata
         Thread.current[:ask_instrumentation_metadata] || {}
       end
+
+      # Create and return a RuntimeAdapter that bridges ask-runtime
+      # EventSink events to Ask::Instrumentation events.
+      #
+      # The returned sink is an Ask::Runtime::EventSink that should be
+      # passed as the +event_sink:+ parameter to an ExecutionContext.
+      # Runtime tool lifecycle events emitted through the sink will be
+      # re-emitted as Ask::Instrumentation events with stable names:
+      #
+      #   tool.started.ask, tool.completed.ask, tool.failed.ask,
+      #   tool.cancelled.ask, tool.timed_out.ask
+      #
+      # If ask-runtime is not available, returns Ask::Runtime::EventSink.null.
+      #
+      # @return [Ask::Runtime::EventSink, Ask::Runtime::EventSink::NullSink]
+      #
+      # @example
+      #   sink = Ask::Instrumentation.install_runtime_sink
+      #   ctx = Ask::Runtime::ExecutionContext.new(event_sink: sink)
+      #
+      def install_runtime_sink
+        require "ask/instrumentation/runtime_adapter"
+        RuntimeAdapter.new.sink
+      rescue LoadError
+        require "ask/runtime"
+        Ask::Runtime::EventSink.null
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-instrumentation
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Kaka Ruto
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: ask-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +95,7 @@ files:
 - lib/ask/instrumentation.rb
 - lib/ask/instrumentation/chat.rb
 - lib/ask/instrumentation/embedding.rb
+- lib/ask/instrumentation/runtime_adapter.rb
 - lib/ask/instrumentation/tool.rb
 - lib/ask/instrumentation/version.rb
 homepage: https://github.com/ask-rb/ask-instrumentation
@@ -104,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.18
 specification_version: 4
 summary: LLM observability for the ask-rb ecosystem
 test_files: []