ruby_llm 2.1.0 → 2.2.0

data/lib/ruby_llm/models.rb

@@ -18,34 +18,18 @@ module RubyLLM
     include Enumerable
     include Lookup
 
-    MODELS_DEV_PROVIDER_MAP = { # :nodoc:
-      'openai' => 'openai',
-      'anthropic' => 'anthropic',
-      'azure' => 'azure',
-      'google' => 'gemini',
-      'google-vertex' => 'vertexai',
-      'amazon-bedrock' => 'bedrock',
-      'cohere' => 'cohere',
-      'deepseek' => 'deepseek',
-      'hetzner' => 'hetzner',
-      'mistral' => 'mistral',
-      'ollama-cloud' => 'ollama_cloud',
-      'openrouter' => 'openrouter',
-      'perplexity' => 'perplexity',
-      'perplexity-agent' => 'perplexity',
-      'xai' => 'xai'
-    }.freeze
     MODELS_DEV_INPUT_MODALITIES = %w[text image audio pdf video file].freeze # :nodoc:
     MODELS_DEV_OUTPUT_MODALITIES = %w[text image audio video embeddings moderation rerank judgment].freeze # :nodoc:
     # First-party providers outrank the aggregators that resell their models.
     PROVIDER_PREFERENCE = %w[
-      openai anthropic gemini deepseek mistral cohere typesafe perplexity xai
+      openai anthropic gemini deepseek mistral cohere typesafe perplexity xai moonshot minimax zai meta
       vertexai bedrock openrouter azure hetzner ollama_cloud ollama gpustack
     ].freeze # :nodoc:
     INSTANCE_DELEGATES = (Enumerable.instance_methods(false) + %i[
       all
       each
       find
+      find_configured
       listed
       unlisted
       chat_models
@@ -149,9 +133,7 @@ module RubyLLM
           existing_models = read_existing_models
 
           provider_fetch = fetch_provider_models(remote_only: remote_only)
-          @last_provider_failures = provider_fetch[:failed]
-          log_provider_fetch(provider_fetch)
-          payload[:failed_providers] = provider_fetch[:failed].map { |failure| failure[:slug] }
+          record_provider_fetch(provider_fetch, payload)
 
           models_dev_fetch = fetch_models_dev_models(existing_models)
           log_models_dev_fetch(models_dev_fetch)
@@ -162,6 +144,12 @@ module RubyLLM
         end
       end
 
+      def record_provider_fetch(provider_fetch, payload) # :nodoc:
+        @last_provider_failures = provider_fetch[:failed]
+        log_provider_fetch(provider_fetch)
+        payload[:failed_providers] = provider_fetch[:failed].map { |failure| failure[:slug] }
+      end
+
       def fetch_provider_models(remote_only: true) # :nodoc:
         config = RubyLLM.config
         providers = remote_only ? Provider.configured_remote_providers(config) : Provider.configured_providers(config)
@@ -210,7 +198,7 @@ module RubyLLM
 
           model ||= Model.default(model_id, provider_class.slug)
         else
-          model = Models.find model_id, provider: provider, config: config
+          model = Models.find_configured model_id, provider: provider, config: config
           provider_class = Provider.resolve!(model.provider)
         end
         [model, provider_class.new(config)]
@@ -237,18 +225,26 @@ module RubyLLM
       def parse_models_dev_catalog(body) # :nodoc:
         raise ModelRegistryError, "models.dev returned #{body.class} instead of a catalog" unless body.is_a?(Hash)
 
-        models = body.flat_map { |provider_key, data| models_dev_provider_models(provider_key, data) }
+        slugs = models_dev_provider_slugs
+        models = body.flat_map do |provider_key, data|
+          models_dev_provider_models(provider_key.to_s, data, slugs[provider_key.to_s])
+        end
         raise ModelRegistryError, 'models.dev returned no models RubyLLM knows a provider for' if models.empty?
 
         models
       end
 
-      def models_dev_provider_models(provider_key, provider_data) # :nodoc:
-        provider_slug = MODELS_DEV_PROVIDER_MAP[provider_key.to_s]
+      def models_dev_provider_slugs # :nodoc:
+        Provider.providers.each_with_object({}) do |(slug, provider), slugs|
+          provider.models_dev_provider_ids.each { |id| slugs[id] ||= slug.to_s }
+        end
+      end
+
+      def models_dev_provider_models(provider_key, provider_data, provider_slug) # :nodoc:
         return [] unless provider_slug
 
         (provider_data[:models] || {}).values.filter_map do |model_data|
-          model = Model.new(models_dev_model_attributes(model_data, provider_slug, provider_key.to_s))
+          model = Model.new(models_dev_model_attributes(model_data, provider_slug, provider_key))
           model unless model.provider.nil? || model.id.nil?
         end
       end
@@ -285,13 +281,7 @@ module RubyLLM
                            .flatten
 
         provider_models = provider_fetch[:models] + preserved_models
-        models_dev_models = if models_dev_fetch[:fetched]
-                              models_dev_fetch[:models]
-                            else
-                              existing_models.select { |model| model.metadata[:source] == 'models.dev' }
-                            end
-
-        merge_models(provider_models, models_dev_models)
+        merge_models(provider_models, models_dev_fetch[:models])
       end
 
       def merge_models(provider_models, models_dev_models) # :nodoc:
@@ -472,7 +462,13 @@ module RubyLLM
         text_tokens = models_dev_text_tokens_pricing(text_standard, cost)
         pricing[:text_tokens] = text_tokens if text_tokens
         pricing[:audio_tokens] = { standard: audio_standard } if audio_standard.any?
-        pricing
+        pricing.merge(models_dev_unit_pricing(cost))
+      end
+
+      def models_dev_unit_pricing(cost) # :nodoc:
+        %i[characters audio_seconds search_units].each_with_object({}) do |unit, pricing|
+          pricing[unit] = { standard: { input_per_million: cost[unit] } } unless cost[unit].nil?
+        end
       end
 
       def models_dev_text_tokens_pricing(text_standard, cost) # :nodoc:
@@ -603,7 +599,7 @@ module RubyLLM
     # the model, first-party providers before aggregators. Raises
     # RubyLLM::ModelNotFoundError if no model matches.
     #
-    #   RubyLLM.models.find 'gpt-5.6'
+    #   RubyLLM.models.find 'gpt-6.1-sol'
     #   RubyLLM.models.find 'claude-sonnet-5', provider: :bedrock
     #
     def find(model_id, provider: nil, config: nil)
@@ -614,6 +610,15 @@ module RubyLLM
       end
     end
 
+    # Returns the Model that resolution uses for +model_id+. Without
+    # +provider+, it prefers providers configured in +config+, falling back
+    # to #find's choice when none of them carries the model.
+    def find_configured(model_id, provider: nil, config: nil) # :nodoc:
+      return find_with_provider(model_id, provider, config) if provider
+
+      find_on_configured_providers(model_id, config || RubyLLM.config)
+    end
+
     # Returns a new Models registry containing only chat models.
     def chat_models
       select_models { |m| m.type == :chat }
@@ -638,7 +643,7 @@ module RubyLLM
 
     # Returns a new Models registry containing only models in +family+.
     #
-    #   RubyLLM.models.by_family('claude3_sonnet')
+    #   RubyLLM.models.by_family('claude-sonnet')
     #
     def by_family(family)
       select_models { |m| m.family == family.to_s }
@@ -668,7 +673,7 @@ module RubyLLM
     def refresh(remote_only: false)
       RubyLLM.instrument('models.refresh.ruby_llm', remote_only:) do |payload|
         published = fetch_published_models
-        main_models = merge_discovered_models(published.models, remote_only:)
+        main_models = merge_discovered_models(published.models, payload, remote_only:)
         merged_models = self.class.merge_models(self.class.models_from_provider_gems, main_models)
         persisted_models = RubyLLM.config.model_registry_store ? merged_models : main_models
         persist_registry!(persisted_models, published:)
@@ -728,9 +733,9 @@ module RubyLLM
       nil
     end
 
-    def merge_discovered_models(published, remote_only:)
+    def merge_discovered_models(published, payload, remote_only:)
       provider_fetch = self.class.fetch_provider_models(remote_only: remote_only)
-      self.class.log_provider_fetch(provider_fetch)
+      self.class.record_provider_fetch(provider_fetch, payload)
       preserved = preserved_providers(provider_fetch, published)
       preserved_models = all.select { |model| preserved.include?(model.provider) }
       self.class.merge_models(provider_fetch[:models] + preserved_models, published)

data/lib/ruby_llm/moderation.rb

@@ -57,8 +57,9 @@ module RubyLLM
     # The provider-assigned identifier of the moderation request.
     attr_reader :id
 
-    # The id of the model that performed the moderation, or +nil+ for an
-    # operation that does not select a model.
+    # The id of the model that performed the moderation. A moderation run
+    # by a provider resource rather than a model names that resource, such
+    # as a Bedrock guardrail's <tt>"id:version"</tt>, as its usage does.
     attr_reader :model
 
     # The per-input verdicts, as an array of Result objects, one per
@@ -82,7 +83,7 @@ module RubyLLM
     # to use a model that is not in the registry. An explicitly selected
     # provider may instead use a configured resource without a model.
     # +owner:+ attributes the usage to a record, such as a user, and wins
-    # over RubyLLM.with_usage_owner.
+    # over RubyLLM.with_owner.
     #
     #   RubyLLM.moderate("User message")
     #   RubyLLM.moderate(["First comment", "Second comment"]).results
@@ -100,33 +101,12 @@ module RubyLLM
       attachments = Attachment.wrap(with)
       raise ArgumentError, 'must provide input text, image attachment, or both' if input.nil? && attachments.empty?
 
-      config = context&.config || RubyLLM.config
-      model, provider_instance = Models.resolve(model, provider: provider, assume_model_exists: assume_model_exists,
-                                                       config: config, operation: :moderate,
-                                                       default_model: config.default_moderation_model)
-      empty_tokens = Tokens.new
-      payload = {
-        provider: provider_instance.slug,
-        provider_class: provider_instance.name,
-        model: model&.id,
-        model_info: model,
-        input: input,
-        attachment_count: attachments.size,
-        provider_options: provider_options,
-        metadata: metadata,
-        tokens: empty_tokens,
-        cost: Cost.new(tokens: empty_tokens, model:)
-      }
-
-      RubyLLM.instrument('moderation.ruby_llm', payload, config: config) do |event|
-        result = Accounting::Usage.owned_by(owner) do
-          provider_instance.moderate(input, model:, with: attachments, provider_options:)
-        end
-        event[:result] = result
-        event[:flagged] = result.flagged?
-        event[:tokens] = result.tokens
-        event[:cost] = result.cost
-        result
+      Accounting::Operation.new(
+        'moderation', model, operation: :moderate, default: :default_moderation_model, provider:, assume_model_exists:,
+                             context:, owner:,
+                             details: ->(event, result) { event[:flagged] = result.flagged? }
+      ).run(input:, attachment_count: attachments.size, provider_options:, metadata:) do |provider_instance, model|
+        provider_instance.moderate(input, model:, with: attachments, provider_options:)
       end
     end
 

data/lib/ruby_llm/ocr.rb

@@ -42,7 +42,7 @@ module RubyLLM
     # into the request in the provider's own vocabulary, such as Mistral's
     # +include_image_base64:+ or +table_format:+.
     # +owner:+ attributes the usage to a record, such as a user, and wins
-    # over RubyLLM.with_usage_owner.
+    # over RubyLLM.with_owner.
     #
     #   RubyLLM.ocr("report.pdf")
     #   RubyLLM.ocr("https://example.com/scan.png")
@@ -59,27 +59,10 @@ module RubyLLM
                  provider_options: {},
                  metadata: nil,
                  owner: nil)
-      config = context&.config || RubyLLM.config
-      model ||= config.default_ocr_model
-      model, provider_instance = Models.resolve(model, provider: provider, assume_model_exists: assume_model_exists,
-                                                       config: config)
-      payload = {
-        provider: provider_instance.slug,
-        provider_class: provider_instance.name,
-        model: model.id,
-        model_info: model,
-        pages: pages,
-        provider_options: provider_options,
-        metadata: metadata
-      }
-
-      RubyLLM.instrument('ocr.ruby_llm', payload, config: config) do |event|
-        result = Accounting::Usage.owned_by(owner) do
-          provider_instance.ocr(file, model:, pages:, provider_options:)
-        end
-        event[:result] = result
-        event[:response_model] = result.model
-        result
+      Accounting::Operation.new(
+        'ocr', model, default: :default_ocr_model, usage: false, provider:, assume_model_exists:, context:, owner:
+      ).run(pages:, provider_options:, metadata:) do |provider_instance, model|
+        provider_instance.ocr(file, model:, pages:, provider_options:)
       end
     end
 

data/lib/ruby_llm/open_telemetry/attributes.rb

@@ -4,6 +4,7 @@ module RubyLLM
   class OpenTelemetry
     module Attributes # :nodoc:
       OPERATIONS = {
+        'agent.ruby_llm' => 'invoke_agent',
         'chat.ruby_llm' => 'chat',
         'embedding.ruby_llm' => 'embeddings',
         'image.ruby_llm' => 'generate_content',
@@ -14,51 +15,60 @@ module RubyLLM
         'moderation.ruby_llm' => 'moderation',
         'judgment.ruby_llm' => 'judgment',
         'tool_call.ruby_llm' => 'execute_tool',
+        'code_execution.ruby_llm' => 'ruby_llm.code_execution',
         'workflow.ruby_llm' => 'invoke_workflow',
         'workflow_step.ruby_llm' => 'ruby_llm.workflow_step'
       }.freeze
-      PROVIDERS = {
-        'bedrock' => 'aws.bedrock',
-        'azure' => 'azure.ai.openai',
-        'gemini' => 'gcp.gen_ai',
-        'vertexai' => 'gcp.vertex_ai',
-        'mistral' => 'mistral_ai',
-        'xai' => 'x_ai'
-      }.freeze
-      INTERNAL_OPERATIONS = %w[execute_tool invoke_workflow ruby_llm.workflow_step].freeze
+      INTERNAL_OPERATIONS = %w[
+        invoke_agent execute_tool invoke_workflow ruby_llm.workflow_step ruby_llm.code_execution
+      ].freeze
 
       module_function
 
-      def span_name(operation, payload)
+      def span_name(operation, payload, content: false)
         target = case operation
-                 when 'execute_tool' then payload[:tool_name]
+                 when 'invoke_agent' then payload[:agent_name]
+                 when 'execute_tool' then [payload[:tool_name], *skill(payload, content:).values]
                  when 'invoke_workflow' then payload[:workflow_name]
                  when 'ruby_llm.workflow_step' then payload[:workflow_step_name]
+                 when 'ruby_llm.code_execution' then payload[:language]
                  else payload[:model]
                  end
-        [operation, target].compact.join(' ')
+        [operation, *target].compact.join(' ')
       end
 
       def span_kind(operation)
         INTERNAL_OPERATIONS.include?(operation) ? :internal : :client
       end
 
-      def request(operation, payload, event:)
+      def request(operation, payload, event:, content: false)
         return workflow(operation, payload) if %w[invoke_workflow ruby_llm.workflow_step].include?(operation)
-        return tool(payload) if operation == 'execute_tool'
+        return agent(payload) if operation == 'invoke_agent'
+        return tool(payload, content:) if operation == 'execute_tool'
+        return code_execution_request(payload) if operation == 'ruby_llm.code_execution'
 
         {
           'gen_ai.operation.name' => operation,
-          'gen_ai.provider.name' => PROVIDERS.fetch(payload[:provider], payload[:provider]),
+          'gen_ai.provider.name' => provider_name(payload[:provider]),
           'gen_ai.request.model' => payload[:model],
           'gen_ai.request.temperature' => payload[:temperature],
           'gen_ai.request.max_tokens' => payload[:max_output_tokens],
           'gen_ai.request.stream' => (true if payload[:streaming]),
+          'gen_ai.request.reasoning.level' => reasoning_level(payload[:thinking]),
           'gen_ai.embeddings.dimension.count' => payload[:dimensions],
           'gen_ai.output.type' => output_type(event, payload)
         }.compact
       end
 
+      def provider_name(slug)
+        provider = Provider.resolve(slug) if slug
+        provider ? provider.open_telemetry_name : slug
+      end
+
+      def reasoning_level(thinking)
+        thinking.effort.to_s if thinking.respond_to?(:effort) && thinking.effort
+      end
+
       def output_type(event, payload)
         return 'json' if payload[:schema]
         return 'image' if event == 'image.ruby_llm'
@@ -69,10 +79,10 @@ module RubyLLM
 
       def response(payload)
         response = payload[:response]
-        attributes = {
+        attributes = code_execution(payload).merge(
           'gen_ai.response.model' => payload[:response_model],
           'gen_ai.response.finish_reasons' => ([response.finish_reason.to_s] if response&.finish_reason)
-        }.compact
+        ).compact
         attributes.merge!(tokens(payload[:response_tokens] || payload[:tokens])) if payload[:tokens]
         attributes
       end
@@ -88,12 +98,51 @@ module RubyLLM
         }.compact
       end
 
-      def tool(payload)
+      def code_execution_request(payload)
+        { 'ruby_llm.code_execution.language' => payload[:language].to_s }
+      end
+
+      def code_execution(payload)
+        return {} unless payload.key?(:timed_out)
+
+        {
+          'ruby_llm.code_execution.exit_code' => payload[:exit_code],
+          'ruby_llm.code_execution.timed_out' => payload[:timed_out],
+          'ruby_llm.code_execution.duration' => payload[:duration]
+        }
+      end
+
+      def tool(payload, content:)
         {
           'gen_ai.operation.name' => 'execute_tool',
           'gen_ai.tool.name' => payload[:tool_name],
           'gen_ai.tool.call.id' => payload[:tool_call_id],
-          'gen_ai.tool.type' => 'function'
+          'gen_ai.tool.description' => payload[:tool]&.description,
+          'gen_ai.tool.type' => 'function',
+          'gen_ai.agent.name' => payload[:agent_name]
+        }.merge(skill(payload, content:)).compact
+      end
+
+      # A skill name the chat does not have, or the file a call asks for,
+      # is a model's argument, so it is content.
+      def skill(payload, content:)
+        loader = payload[:tool]
+        arguments = payload[:tool_arguments].to_h.transform_keys(&:to_s)
+        name = arguments['skill'].to_s
+        return {} unless loader.is_a?(Skill::Loader) && loader.skill?(name)
+
+        {
+          'gen_ai.skill.name' => name,
+          'gen_ai.skill.resource.name' => (Skill::Loader.resource_name(name, arguments['file']) if content)
+        }.compact
+      end
+
+      def agent(payload)
+        {
+          'gen_ai.operation.name' => 'invoke_agent',
+          'gen_ai.agent.name' => payload[:agent_name],
+          'gen_ai.agent.description' => payload[:agent_description],
+          'gen_ai.conversation.id' => payload[:chat_id]&.to_s
         }.compact
       end
 

data/lib/ruby_llm/open_telemetry/content.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class OpenTelemetry
+    # The opt-in content attributes, in the GenAI semantic conventions'
+    # message format. Attachments are described, never sent as bytes.
+    module Content # :nodoc:
+      module_function
+
+      def request(operation, payload)
+        case operation
+        when 'chat' then chat_request(payload[:input_messages] || [])
+        when 'execute_tool' then { 'gen_ai.tool.call.arguments' => json(payload[:tool_arguments]) }
+        else {}
+        end.compact
+      end
+
+      def response(operation, payload)
+        case operation
+        when 'chat' then chat_response(payload[:response])
+        when 'execute_tool' then { 'gen_ai.tool.call.result' => tool_result(payload[:result]) }
+        else {}
+        end.compact
+      end
+
+      def chat_request(messages)
+        system, conversation = messages.partition { |message| message.role == :system }
+        {
+          'gen_ai.system_instructions' => (json(system.flat_map { |message| parts(message) }) if system.any?),
+          'gen_ai.input.messages' => (json(conversation.map { |message| message(message) }) if conversation.any?)
+        }
+      end
+
+      def chat_response(response)
+        return {} unless response.is_a?(Message)
+
+        output = message(response)
+        output[:finish_reason] = response.finish_reason.to_s if response.finish_reason
+        { 'gen_ai.output.messages' => json([output]) }
+      end
+
+      def message(message)
+        { role: message.role.to_s, parts: parts(message) }
+      end
+
+      def parts(message)
+        return tool_parts(message) if message.role == :tool
+
+        thinking = message.thinking&.text
+        [
+          ({ type: 'reasoning', content: thinking } if present?(thinking)),
+          ({ type: 'text', content: message.content } if present?(message.content)),
+          *message.attachments.map { |attachment| attachment(attachment) },
+          *message.tool_calls.map { |call| tool_call(call) }
+        ].compact
+      end
+
+      def tool_parts(message)
+        [{ type: 'tool_call_response', id: message.tool_call_id, response: message.content },
+         *message.attachments.map { |attachment| attachment(attachment) }]
+      end
+
+      def tool_call(call)
+        { type: 'tool_call', id: call.id, name: call.name, arguments: call.arguments }
+      end
+
+      def attachment(attachment)
+        described = { modality: attachment.type.to_s, mime_type: attachment.mime_type }
+        if attachment.provider_file?
+          { type: 'file', **described, file_id: attachment.provider_file_id }
+        elsif attachment.url?
+          { type: 'uri', **described, uri: uri_without_credentials(attachment.source) }
+        else
+          { type: 'attachment', **described, filename: attachment.filename }
+        end
+      end
+
+      # What the model receives from the tool, with attachments described.
+      def tool_result(result)
+        return if result.nil?
+
+        content, attachments = Tool.split_result(result)
+        return content if attachments.empty?
+
+        json([({ type: 'text', content: } if present?(content)), *attachments.map { |item| attachment(item) }].compact)
+      end
+
+      # Signed URLs carry access credentials in their query string.
+      def uri_without_credentials(source)
+        uri = URI(source.to_s)
+        uri.class.build(host: uri.host, port: uri.port, path: uri.path).to_s
+      end
+
+      def present?(text)
+        text.is_a?(String) && !text.empty?
+      end
+
+      def json(value)
+        return if value.nil?
+
+        value.is_a?(String) ? value : JSON.generate(value)
+      end
+    end
+  end
+end

data/lib/ruby_llm/open_telemetry.rb

@@ -10,9 +10,16 @@ module RubyLLM
       # Enables tracing without replacing the configured instrumenter.
       # Requires the optional opentelemetry-api gem. Repeated calls are harmless.
       # The application owns the tracer provider, SDK, and exporters.
-      def enable
+      # With <tt>content: true</tt>, spans also carry instructions, messages,
+      # model output, and tool arguments and results.
+      #
+      #   RubyLLM::OpenTelemetry.enable
+      #   RubyLLM::OpenTelemetry.enable(content: true)
+      #
+      def enable(content: false)
         require 'opentelemetry-api'
         @mutex.synchronize do
+          @content = content
           @subscriber ||= new
           Support::Instrumentation.subscribe(@subscriber)
         end
@@ -27,16 +34,22 @@ module RubyLLM
         @mutex.synchronize { Support::Instrumentation.unsubscribe(@subscriber) if @subscriber }
         nil
       end
+
+      def content? # :nodoc:
+        @content == true
+      end
     end
 
     def instrument(name, payload) # :nodoc:
       operation = Attributes::OPERATIONS[name]
       return yield unless operation
 
+      content = self.class.content?
       span = safely do
-        tracer.start_span(Attributes.span_name(operation, payload),
-                          kind: Attributes.span_kind(operation),
-                          attributes: Attributes.request(operation, payload, event: name))
+        attributes = Attributes.request(operation, payload, event: name, content:)
+        attributes.merge!(Content.request(operation, payload)) if content
+        span_name = Attributes.span_name(operation, payload, content:)
+        tracer.start_span(span_name, kind: Attributes.span_kind(operation), attributes:)
       end
       return yield unless span
 
@@ -47,6 +60,7 @@ module RubyLLM
         raise
       ensure
         safely { span.add_attributes(Attributes.response(payload)) }
+        safely { span.add_attributes(Content.response(operation, payload)) } if content
         safely { span.finish }
       end
     end

data/lib/ruby_llm/prompt/context.rb

@@ -7,7 +7,7 @@
 # RubyLLM lexical scope: +Chat+ in a template is the application's model,
 # not RubyLLM::Chat.
 class RubyLLM::Prompt::Context # rubocop:disable Style/ClassAndModuleChildren
-  LOCAL_VARIABLE_NAME = /\A(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/
+  LOCAL_VARIABLE_NAME = /\A(?![[:upper:]\p{Lt}0-9])[[:alnum:]_[:^ascii:]]+\z/
   private_constant :LOCAL_VARIABLE_NAME
 
   # Returns the locals passed to the current prompt or partial. Use it to
@@ -46,7 +46,7 @@ class RubyLLM::Prompt::Context # rubocop:disable Style/ClassAndModuleChildren
 
   def partial(name)
     name = name.to_s
-    partial = name.sub(%r{([^/]+)\z}, '_\\1')
+    partial = name.sub(%r{(\A|/)([^/]+)\z}, '\\1_\\2')
     directory = File.dirname(@prompt.name)
     return RubyLLM::Prompt.new(partial) if name.include?('/') || directory == '.'
 

data/lib/ruby_llm/prompt.rb

@@ -6,13 +6,15 @@ require 'pathname'
 module RubyLLM
   # Resolves prompt templates from the application and registered engine directories.
   class Prompt
-    # The ordered directories searched for prompt files. The application's
-    # prompt directory is always first, so an application can override any
-    # prompt an engine ships by placing a file at the same relative path.
-    # Engines append their own directory in an initializer:
+    # The ordered directories searched for prompt files, and for skills
+    # through Skill.roots. The application's directory is always first, so
+    # an application can override any prompt or skill an engine ships by
+    # placing its own at the same relative path. Engines append their own
+    # directories in an initializer:
     #
     #   initializer "my_engine.prompts" do
     #     RubyLLM::Prompt.roots << MyEngine::Engine.root.join("app/prompts")
+    #     RubyLLM::Skill.roots << MyEngine::Engine.root.join("app/skills")
     #   end
     #
     class Roots
@@ -50,7 +52,7 @@ module RubyLLM
     def render(**locals) # :nodoc:
       raise PromptNotFoundError, "Prompt file not found: #{path}" unless File.exist?(path)
 
-      ERB.new(File.read(path)).result(Context.new(self, locals).scope)
+      ERB.new(File.read(path, encoding: Encoding::UTF_8), trim_mode: '-').result(Context.new(self, locals).scope)
     end
 
     def self.render(name, **locals) # :nodoc:

data/lib/ruby_llm/protocol/binary_streaming.rb

@@ -8,14 +8,8 @@ module RubyLLM
         fallback = Streaming::StreamState.new
         on_data = binary_on_data(fallback, progress, &)
 
-        response = @connection.post(url, payload, usage: @usage_tracker, stream: true) do |request|
-          (request.options.context ||= {})[Transport::Connection::STREAM_PROGRESS_KEY] = progress
-          if faraday_1?
-            request.options[:on_data] = on_data
-          else
-            request.options.on_data = on_data
-          end
-        end
+        response = post_stream(url, payload, on_data:, progress:, on_reset: fallback.method(:reset),
+                                             on_failure: stream_failure(fallback))
         state = response.env[:streaming_state] || fallback
         validate_binary_response(response, state.buffer)
         yield state.buffer.dup unless progress[:started] || state.buffer.empty?