myrr-rb 0.3.3

data/lib/myrr/pay/client.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Myrr
+  module Pay
+    # Client for a seller's Myrr Pay API.
+    #
+    # Wraps the HTTP endpoints that sellers expose for agents to
+    # create customers, check balances, top-up, and manage subscriptions.
+    #
+    # @example
+    #   client = Myrr::Pay::Client.new(base_url: "https://seller.example.com")
+    #   client.create_customer(agent_did: "did:myrr:abc123")
+    #   client.get_balance(agent_did: "did:myrr:abc123")
+    class Client
+      # @param base_url [String] The seller's Myrr protocol server URL
+      # @param api_key [String, nil] Optional API key for internal endpoints
+      # @param open_timeout [Integer] HTTP open timeout (seconds)
+      # @param read_timeout [Integer] HTTP read timeout (seconds)
+      def initialize(base_url:, api_key: nil, open_timeout: 5, read_timeout: 10)
+        require "net/http"
+        require "uri"
+
+        @base_url = base_url
+        @api_key = api_key
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+      end
+
+      # Create a Stripe Customer for the agent on this seller's account.
+      #
+      # @param agent_did [String] The did:myrr: identifier
+      # @return [Hash] Response with stripe_customer_id, balance, currency
+      def create_customer(agent_did:)
+        post("/v1/pay/customers", { agent_did: agent_did })
+      end
+
+      # Get the agent's current balance on this seller.
+      #
+      # @param agent_did [String] The did:myrr: identifier
+      # @return [Hash] Response with balance_cents, currency
+      def get_balance(agent_did:)
+        get("/v1/pay/balance", { agent_did: agent_did })
+      end
+
+      # Top up the agent's balance via off_session PaymentIntent.
+      #
+      # @param agent_did [String] The did:myrr: identifier
+      # @param amount_cents [Integer] Amount in cents
+      # @param payment_method_id [String] Stripe PaymentMethod ID
+      # @return [Hash] Response with payment_intent_id, status, amount_cents
+      def topup(agent_did:, amount_cents:, payment_method_id:)
+        post("/v1/pay/topup", {
+          agent_did: agent_did,
+          amount_cents: amount_cents,
+          payment_method_id: payment_method_id
+        })
+      end
+
+      # Debit the agent's balance (internal — requires API key).
+      #
+      # @param agent_did [String] The did:myrr: identifier
+      # @param amount_cents [Integer] Amount in cents
+      # @param endpoint_path [String] The endpoint being accessed
+      # @param token_count [Integer] Number of tokens consumed
+      # @param description [String, nil] Optional description
+      # @return [Hash] Response with status, amount_cents, balance_cents
+      def debit(agent_did:, amount_cents:, endpoint_path: "", token_count: 0, description: nil)
+        body = {
+          agent_did: agent_did,
+          amount_cents: amount_cents,
+          endpoint_path: endpoint_path,
+          token_count: token_count
+        }
+        body[:description] = description if description
+        post("/v1/pay/debit", body)
+      end
+
+      # Create a subscription for the agent.
+      #
+      # @param agent_did [String] The did:myrr: identifier
+      # @param payment_method_id [String] Stripe PaymentMethod ID
+      # @param plan_name [String] Name of the plan (matches pricing config)
+      # @return [Hash] Response with subscription details
+      def create_subscription(agent_did:, payment_method_id:, plan_name:)
+        post("/v1/pay/subscriptions", {
+          agent_did: agent_did,
+          payment_method_id: payment_method_id,
+          plan_name: plan_name
+        })
+      end
+
+      # Get the agent's active subscription.
+      #
+      # @param agent_did [String] The did:myrr: identifier
+      # @return [Hash] Response with subscription details or nil
+      def get_subscription(agent_did:)
+        get("/v1/pay/subscriptions", { agent_did: agent_did })
+      end
+
+      # Public method for direct API calls (used by middleware)
+      def get(path, params = {})
+        uri = URI.join(@base_url, path)
+        uri.query = URI.encode_www_form(params) unless params.empty?
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        http.use_ssl = (uri.scheme == "https")
+
+        request = Net::HTTP::Get.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@api_key}" if @api_key
+
+        response = http.request(request)
+        parse_response(response)
+      end
+
+      def post(path, body = {})
+        uri = URI.join(@base_url, path)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        http.use_ssl = (uri.scheme == "https")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@api_key}" if @api_key
+        request.body = body.to_json
+
+        response = http.request(request)
+        parse_response(response)
+      end
+
+      def parse_response(response)
+        data = JSON.parse(response.body)
+        case response.code.to_i
+        when 200..299
+          data
+        when 402
+          raise Myrr::Pay::InsufficientFunds, data["error"]
+        when 404
+          raise Myrr::Pay::NotFound, data["error"]
+        else
+          raise Myrr::Pay::Error, data["error"] || "HTTP #{response.code}"
+        end
+      rescue JSON::ParserError
+        raise Myrr::Pay::Error, "Invalid JSON response (HTTP #{response.code})"
+      end
+    end
+  end
+end

data/lib/myrr/pay/middleware.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "../client"
+
+module Myrr
+  module Pay
+    # Rack middleware that enforces payment on the sell-side.
+    #
+    # Runs after identity middleware. For agent requests to paid endpoints,
+    # it checks the pricing from the Go server, then checks subscription
+    # or balance, debits if possible, or returns 402.
+    #
+    # @example In a Rails app
+    #   # config/application.rb
+    #   config.middleware.use Myrr::Pay::Middleware
+    class Middleware
+      # @param app [Object] The Rack application
+      # @param options [Hash] Optional overrides
+      #   :client [Myrr::Pay::Client] Pre-configured pay client
+      def initialize(app, options = {})
+        @app = app
+        @client = options[:client]
+      end
+
+      def call(env)
+        @env = env
+        request = Rack::Request.new(env)
+
+        # Skip for non-agent requests
+        agent_did = env["myrr.agent_did"]
+        unless agent_did
+          return @app.call(env)
+        end
+
+        # Get pricing from Go server
+        pricing = fetch_pricing
+        unless pricing && pricing_requires_payment?(pricing)
+          # Free endpoint — pass through
+          return @app.call(env)
+        end
+
+        payg_cents = pricing.dig("payg", "per_1m_tokens_cents") || 0
+
+        # Check subscription first
+        sub = check_subscription(agent_did)
+        if sub && sub["status"] == "active"
+          tokens_remaining = (sub["tokens_included"] || 0) - (sub["tokens_used"] || 0)
+
+          if tokens_remaining > 0
+            # Serve content — billing happens after render
+            status, headers, body = @app.call(env)
+
+            content_type = headers["content-type"] || headers["Content-Type"] || ""
+            if content_type.include?("text/markdown")
+              body_text = ""
+              body.each { |chunk| body_text << chunk.to_s }
+              body.rewind if body.respond_to?(:rewind)
+
+              token_count = count_tokens(body_text)
+              if token_count <= tokens_remaining
+                headers["X-Myrr-Billing"] = "subscription"
+              end
+            end
+
+            return [status, headers, body]
+          end
+        end
+
+        # Subscription exhausted or none — check PAYG balance
+        status, headers, body = @app.call(env)
+
+        content_type = headers["content-type"] || headers["Content-Type"] || ""
+        unless content_type.include?("text/markdown")
+          return [status, headers, body]
+        end
+
+        body_text = ""
+        body.each { |chunk| body_text << chunk.to_s }
+        body.rewind if body.respond_to?(:rewind)
+
+        token_count = count_tokens(body_text)
+        amount_cents = pay_cents(payg_cents, token_count)
+        return [status, headers, body] if amount_cents <= 0
+
+        # Check balance
+        balance = check_balance(agent_did) || 0
+
+        if balance >= amount_cents
+          # Debit
+          debit_agent!(agent_did, amount_cents, request.path_info, token_count)
+          headers["X-Myrr-Billing"] = "payg"
+          [status, headers, body]
+        else
+          # Return 402
+          [402, { "content-type" => "application/json" }, [render_402(request, token_count, amount_cents, payg_cents)]]
+        end
+      rescue => e
+        warn "[myrr] Pay middleware error: #{e.message}"
+        @app.call(env)
+      end
+
+      private
+
+      def client
+        @client ||= Myrr::Pay::Client.new(
+          base_url: Myrr.config.protocol_server_url,
+          api_key: Myrr.config.site_api_key
+        )
+      end
+
+      def fetch_pricing
+        client.get("/v1/pricing")
+      rescue => e
+        warn "[myrr] Failed to fetch pricing: #{e.message}"
+        nil
+      end
+
+      def pricing_requires_payment?(pricing)
+        payg = pricing.dig("payg", "per_1m_tokens_cents")
+        sub = pricing["subscription"]
+        (payg && payg > 0) || (sub && sub["monthly_cents"] && sub["monthly_cents"] > 0)
+      rescue
+        false
+      end
+
+      def check_subscription(agent_did)
+        client.get_subscription(agent_did: agent_did)
+      rescue Myrr::Pay::NotFound
+        nil
+      rescue => e
+        warn "[myrr] Subscription check failed: #{e.message}"
+        nil
+      end
+
+      def check_balance(agent_did)
+        resp = client.get_balance(agent_did: agent_did)
+        resp["balance_cents"].to_i
+      rescue => e
+        warn "[myrr] Balance check failed: #{e.message}"
+        0
+      end
+
+      def debit_agent!(agent_did, amount_cents, endpoint_path, token_count)
+        client.debit(
+          agent_did: agent_did,
+          amount_cents: amount_cents,
+          endpoint_path: endpoint_path,
+          token_count: token_count
+        )
+      rescue => e
+        warn "[myrr] Debit failed: #{e.message}"
+      end
+
+      def count_tokens(text)
+        if defined?(Myrr::Tokenizer)
+          Myrr::Tokenizer.count(text)
+        else
+          (text.length / 4.0).ceil
+        end
+      end
+
+      def pay_cents(cents_per_million, token_count)
+        return 0 if cents_per_million.nil? || cents_per_million <= 0 || token_count.nil? || token_count <= 0
+        charge = (cents_per_million.to_f * token_count.to_f / 1_000_000.0).ceil
+        [charge, 1].max
+      end
+
+      def render_402(request, token_count, amount_cents, payg_cents)
+        JSON.generate({
+          error: "payment_required",
+          payment: {
+            type: "stripe_customer_balance",
+            endpoint: request.path_info,
+            token_count: token_count,
+            amount_cents: amount_cents,
+            pricing: { per_1m_tokens_cents: payg_cents },
+            actions: {
+              topup_url: "/v1/pay/topup",
+              check_balance_url: "/v1/pay/balance"
+            }
+          }
+        })
+      end
+    end
+  end
+end

data/lib/myrr/pay.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "pay/client"
+require_relative "pay/middleware"
+
+module Myrr
+  module Pay
+    Error = Class.new(StandardError)
+    InsufficientFunds = Class.new(Error)
+    NotFound = Class.new(Error)
+    SubscriptionExhausted = Class.new(Error)
+  end
+end

data/lib/myrr/port/metadata.rb

@@ -0,0 +1,79 @@
+require "yaml"
+
+module Myrr
+  module Port
+    # Controller concern that extracts page metadata (title, description)
+    # from common Rails conventions and inline front-matter in .md.erb views.
+    #
+    # Detection order (highest priority first):
+    # 1. Inline YAML front-matter in the .md.erb template — view wins
+    # 2. +@myrr_title+ / +@myrr_description+ — explicit override
+    # 3. +@page_title+ / +@page_description+ — Jumpstart convention
+    # 4. +@title+ / +@meta_description+ — standard Rails pattern
+    # 5. +content_for(:title)+ — popular in view-level title setting
+    # 6. +Current.meta_tags&.title+ / +Current.meta_tags&.description+
+    #
+    # Inline front-matter values override auto-detected values for
+    # overlapping keys. Auto-detected fills in any missing fields.
+    # +token_count+ is never set here — the middleware always computes it.
+    module Metadata
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :set_myrr_metadata
+      end
+
+      private
+
+      def set_myrr_metadata
+        return if request.env.key?("myrr.metadata")
+
+        inline = inline_frontmatter_from_template
+        auto = { title: detect_title, description: detect_description }.compact
+
+        if inline
+          request.env["myrr.metadata"] = auto.merge(inline)
+        else
+          request.env["myrr.metadata"] = auto
+        end
+      end
+
+      # Reads the .md.erb template source for the current action and checks
+      # for YAML front-matter (delimited by ---). Returns parsed Hash or nil.
+      def inline_frontmatter_from_template
+        tmpl = lookup_context.find(
+          action_name,
+          lookup_context.prefixes,
+          false,
+          [],
+          { formats: [:md] }
+        )
+        return nil unless tmpl
+
+        source = tmpl.source
+        return nil unless source.start_with?("---\n") || source.start_with?("---\r\n")
+
+        nl = source.start_with?("---\r\n") ? "\r\n" : "\n"
+        rest = source[4..]
+        end_idx = rest.index(nl + "---" + nl)
+        return nil unless end_idx
+
+        yaml_str = rest[0...end_idx]
+        YAML.safe_load(yaml_str, permitted_classes: [Symbol])&.transform_keys(&:to_sym)
+      rescue
+        nil
+      end
+
+      def detect_title
+        @myrr_title || @page_title || @title ||
+          view_context&.content_for(:title).presence ||
+          (defined?(Current) && Current.meta_tags&.title)
+      end
+
+      def detect_description
+        @myrr_description || @page_description || @meta_description ||
+          (defined?(Current) && Current.meta_tags&.description)
+      end
+    end
+  end
+end

data/lib/myrr/port/middleware.rb

@@ -0,0 +1,113 @@
+require "yaml"
+
+module Myrr
+  module Port
+    class Middleware
+      HEADER_NAME = "X-Token-Count"
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, body_out = @app.call(env)
+
+        if content_type_is_markdown?(headers)
+          raw_body = extract_body(body_out)
+          resolved_body, meta = resolve_metadata(raw_body, env["myrr.metadata"] || {})
+
+          if meta[:title] || meta[:description]
+            resolved_body = build_frontmatter_body(resolved_body, meta)
+          end
+
+          token_count = Myrr::Tokenizer.count(resolved_body)
+          headers[HEADER_NAME] = token_count.to_s
+          body_out = [resolved_body]
+        end
+
+        [status, headers, body_out]
+      end
+
+      private
+
+      def content_type_is_markdown?(headers)
+        headers["content-type"].to_s.include?("text/markdown")
+      end
+
+      def extract_body(body)
+        text = +""
+        body.each { |chunk| text << chunk.to_s }
+        text
+      end
+
+      # --- Metadata resolution ---
+
+      def resolve_metadata(raw_body, auto_meta)
+        if auto_meta[:title] || auto_meta[:description]
+          [strip_inline_frontmatter(raw_body), auto_meta]
+        else
+          inline = parse_inline_frontmatter(raw_body)
+          inline ? [inline[:body], inline[:data]] : [raw_body, {}]
+        end
+      end
+
+      def strip_inline_frontmatter(body)
+        return body unless body.start_with?("---\n") || body.start_with?("---\r\n")
+        nl = body.start_with?("---\r\n") ? "\r\n" : "\n"
+        rest = body[4..]
+        end_idx = rest.index(nl + "---" + nl)
+        return body unless end_idx
+        rest[(end_idx + 5 + nl.length)..] || ""
+      end
+
+      def parse_inline_frontmatter(body)
+        return nil unless body.start_with?("---\n") || body.start_with?("---\r\n")
+        nl = body.start_with?("---\r\n") ? "\r\n" : "\n"
+        rest = body[4..]
+        end_idx = rest.index(nl + "---" + nl)
+        return nil unless end_idx
+        yaml_str = rest[0...end_idx]
+        data = (YAML.safe_load(yaml_str, permitted_classes: [Symbol]) || {}).transform_keys(&:to_sym)
+        content = rest[(end_idx + 5 + nl.length)..] || ""
+        { data: data, body: content }
+      rescue
+        nil
+      end
+
+      # --- Front-matter builder (self-consistent token_count) ---
+      #
+      # The token_count value is part of the body it counts, so we
+      # converge iteratively: measure → insert → remeasure.  2-3 passes
+      # are sufficient for typical cases.
+
+      def build_frontmatter_body(body_text, metadata)
+        lines = ["---"]
+        lines << yaml_value("title", metadata[:title])
+        lines << yaml_value("description", metadata[:description])
+        lines << "---"
+
+        # Pass 1: measure without token_count.
+        pass1 = lines.compact.join("\n") + "\n\n" + body_text
+        count = Myrr::Tokenizer.count(pass1)
+
+        # Pass 2: insert and measure.
+        lines.insert(-2, "token_count: #{count}")
+        pass2 = lines.compact.join("\n") + "\n\n" + body_text
+        true_count = Myrr::Tokenizer.count(pass2)
+
+        # If still off, rebuild one more time.
+        if true_count != count
+          lines[-2] = "token_count: #{true_count}"
+          lines.compact.join("\n") + "\n\n" + body_text
+        else
+          pass2
+        end
+      end
+
+      def yaml_value(key, value)
+        return nil if value.nil?
+        "#{key}: \"#{value.to_s.gsub('"', '\\"')}\""
+      end
+    end
+  end
+end

data/lib/myrr/rack/middleware.rb

@@ -0,0 +1,93 @@
+module Myrr
+  module Rack
+    # Rack middleware that detects X-Myrr-Agent headers on incoming requests,
+    # performs challenge-response verification against the protocol server
+    # (or uses a configured identity_adapter), and sets
+    # +request.env["myrr.current_agent"]+.
+    #
+    # After the inner app runs, if the response is text/markdown, it counts
+    # the tokens and adds +env["myrr.token_count"]+ and the
+    # +X-Myrr-Tokens+ response header.
+    class Middleware
+      # @param app [Rack app] The downstream Rack application
+      # @param myrr [Module] The Myrr module (defaults to Myrr)
+      def initialize(app, myrr_module = nil)
+        @app = app
+        @myrr = myrr_module || Myrr
+      end
+
+      # @param env [Hash] Rack environment
+      def call(env)
+        agent_did = env["HTTP_X_MYRR_AGENT"]
+
+        if agent_did && !agent_did.empty?
+          begin
+            agent_info = @myrr.verify_agent(agent_did)
+            if agent_info
+              env["myrr.current_agent"] = agent_info
+              override_format_to_markdown(env) if should_override_format?(env)
+            end
+          rescue => e
+            if @myrr.config&.fail_open
+              warn "[myrr] Agent verification failed (fail_open=true): #{e.message}"
+            else
+              return fail_response(env, e.message)
+            end
+          end
+        end
+
+        status, headers, body = @app.call(env)
+
+        # Token counting for markdown responses
+        if env["myrr.current_agent"] && content_type_is_markdown?(headers)
+          body_text = extract_body(body)
+          token_count = @myrr::Tokenizer.count(body_text)
+          env["myrr.token_count"] = token_count
+          headers["X-Myrr-Tokens"] = token_count.to_s
+        end
+
+        [status, headers, body]
+      end
+
+      private
+
+      def content_type_is_markdown?(headers)
+        content_type = headers["content-type"].to_s
+        content_type.include?("text/markdown")
+      end
+
+      def extract_body(body)
+        body_text = +""
+        body.each { |chunk| body_text << chunk.to_s }
+        body_text
+      end
+
+      # Determine whether to override the request format to markdown.
+      def should_override_format?(env)
+        return false unless @myrr.config&.auto_format_md != false
+
+        path = env["PATH_INFO"].to_s
+        return false if path.match?(/\.[a-z0-9]+\z/)
+
+        accept = env["HTTP_ACCEPT"].to_s.strip
+        return false unless accept.empty? || accept == "*/*"
+
+        true
+      end
+
+      def override_format_to_markdown(env)
+        env["myrr.original_accept"] = env["HTTP_ACCEPT"]
+        env["HTTP_ACCEPT"] = "text/markdown"
+      end
+
+      def fail_response(env, message)
+        body = JSON.generate({
+          error: "identity_verification_failed",
+          message: message
+        })
+
+        [502, { "content-type" => "application/json" }, [body]]
+      end
+    end
+  end
+end

data/lib/myrr/railtie.rb

@@ -0,0 +1,25 @@
+require_relative "port/metadata"
+
+module Myrr
+  # Rails integration for myrr-rb.
+  #
+  # Automatically:
+  # 1. Registers the +text/markdown+ MIME type
+  # 2. Mounts the port middleware for token counting and front-matter
+  # 3. Injects the metadata concern into all controllers
+  class Railtie < Rails::Railtie
+    initializer "myrr.register_mime_type" do
+      Mime::Type.register "text/markdown", :md
+    end
+
+    initializer "myrr.port_middleware" do |app|
+      app.config.middleware.use Myrr::Port::Middleware
+    end
+
+    initializer "myrr.port_metadata" do
+      ActiveSupport.on_load(:action_controller_base) do
+        include Myrr::Port::Metadata
+      end
+    end
+  end
+end

data/lib/myrr/tokenizer.rb

@@ -0,0 +1,28 @@
+require "tiktoken_ruby"
+
+module Myrr
+  # Token counting for agent responses.
+  #
+  # Uses OpenAI's cl100k_base encoding via tiktoken_ruby to count tokens
+  # in rendered markdown responses.
+  #
+  # @example
+  #   Myrr::Tokenizer.count("Hello, world!")  # => 4
+  module Tokenizer
+    ENCODING_MODEL = "gpt-4"  # Uses cl100k_base encoding
+
+    class << self
+      # Count the number of tokens in the given text.
+      #
+      # Uses OpenAI's cl100k_base encoding via tiktoken_ruby.
+      #
+      # @param text [String] The text to count tokens for
+      # @return [Integer] Number of tokens
+      def count(text)
+        return 0 if text.nil? || text.strip.empty?
+        enc = Tiktoken.encoding_for_model(ENCODING_MODEL)
+        enc.encode(text).length
+      end
+    end
+  end
+end