datagrout-conduit 0.1.0

data/lib/datagrout_conduit/transport/mcp.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  module Transport
+    # MCP Streamable HTTP transport.
+    # Sends JSON-RPC requests via HTTP POST to the MCP endpoint.
+    class Mcp < Base
+      def initialize(url:, auth: {}, identity: nil)
+        super
+        @session_id = nil
+      end
+
+      def send_request(method, params = nil, id: nil)
+        ensure_connected!
+
+        request_id = id || next_id
+        body = build_jsonrpc_body(method, params, request_id)
+        headers = build_headers
+
+        response = @connection.post do |req|
+          req.headers = headers
+          req.body = JSON.generate(body)
+        end
+
+        track_session_id(response)
+        result = handle_response(response)
+
+        if result == :retry_oauth
+          headers = build_headers
+          response = @connection.post do |req|
+            req.headers = headers
+            req.body = JSON.generate(body)
+          end
+          track_session_id(response)
+          result = handle_response(response)
+          raise AuthError, "OAuth token rejected after refresh" if result == :retry_oauth
+        end
+
+        result
+      end
+
+      private
+
+      def build_headers
+        headers = super
+        headers["Accept"] = "application/json, text/event-stream"
+        headers["Mcp-Session-Id"] = @session_id if @session_id
+        headers
+      end
+
+      def track_session_id(response)
+        sid = response.headers["mcp-session-id"]
+        @session_id = sid if sid
+      end
+
+      def handle_response(response)
+        check_rate_limit!(response)
+
+        if response.status == 401 && @auth[:type] == :oauth
+          @auth[:provider].invalidate!
+          return :retry_oauth
+        end
+
+        return { "accepted" => true } if response.status == 202
+
+        unless response.success?
+          raise ConnectionError, "HTTP #{response.status} error"
+        end
+
+        content_type = response.headers["content-type"].to_s
+
+        if content_type.include?("text/event-stream")
+          messages = parse_sse(response.body.to_s)
+          body = messages.last || {}
+        else
+          body = response.body
+          body = JSON.parse(body) if body.is_a?(String)
+        end
+
+        if body.is_a?(Hash) && body["error"]
+          err = body["error"]
+          raise McpError.new(
+            code: err["code"] || -1,
+            message: err["message"] || "Unknown error",
+            data: err["data"]
+          )
+        end
+
+        body
+      end
+
+      def parse_sse(body)
+        messages = []
+        body.split("\n\n").each do |chunk|
+          chunk.each_line do |line|
+            if line.start_with?("data:")
+              data = line.sub(/^data:\s*/, "").strip
+              next if data.empty?
+              messages << JSON.parse(data)
+            end
+          end
+        end
+        messages
+      end
+    end
+  end
+end

data/lib/datagrout_conduit/types.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  Tool = Struct.new(:name, :description, :input_schema, :annotations, keyword_init: true) do
+    def self.from_hash(hash)
+      hash = normalize_keys(hash)
+      new(
+        name: hash[:name],
+        description: hash[:description],
+        input_schema: hash[:input_schema] || hash[:inputschema],
+        annotations: hash[:annotations]
+      )
+    end
+
+    def self.normalize_keys(hash)
+      hash.each_with_object({}) do |(k, v), memo|
+        memo[k.to_s.downcase.to_sym] = v
+      end
+    end
+  end
+
+  Byok = Struct.new(:enabled, :discount_applied, :discount_rate, keyword_init: true) do
+    def self.from_hash(hash)
+      return new(enabled: false, discount_applied: 0.0, discount_rate: 0.0) if hash.nil?
+
+      hash = hash.transform_keys(&:to_s)
+      new(
+        enabled: hash["enabled"] || false,
+        discount_applied: (hash["discount_applied"] || 0.0).to_f,
+        discount_rate: (hash["discount_rate"] || 0.0).to_f
+      )
+    end
+  end
+
+  Receipt = Struct.new(
+    :receipt_id, :transaction_id, :timestamp,
+    :estimated_credits, :actual_credits, :net_credits,
+    :savings, :savings_bonus,
+    :balance_before, :balance_after,
+    :breakdown, :byok,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      hash = hash.transform_keys(&:to_s)
+      new(
+        receipt_id: hash["receipt_id"],
+        transaction_id: hash["transaction_id"],
+        timestamp: hash["timestamp"],
+        estimated_credits: hash["estimated_credits"]&.to_f,
+        actual_credits: hash["actual_credits"]&.to_f,
+        net_credits: hash["net_credits"]&.to_f,
+        savings: (hash["savings"] || 0.0).to_f,
+        savings_bonus: (hash["savings_bonus"] || 0.0).to_f,
+        balance_before: hash["balance_before"]&.to_f,
+        balance_after: hash["balance_after"]&.to_f,
+        breakdown: hash["breakdown"] || {},
+        byok: Byok.from_hash(hash["byok"])
+      )
+    end
+  end
+
+  CreditEstimate = Struct.new(
+    :estimated_total, :actual_total, :net_total, :breakdown,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      hash = hash.transform_keys(&:to_s)
+      new(
+        estimated_total: hash["estimated_total"]&.to_f,
+        actual_total: hash["actual_total"]&.to_f,
+        net_total: hash["net_total"]&.to_f,
+        breakdown: hash["breakdown"] || {}
+      )
+    end
+  end
+
+  ToolMeta = Struct.new(:receipt, :credit_estimate, keyword_init: true) do
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      hash = hash.transform_keys(&:to_s)
+      new(
+        receipt: Receipt.from_hash(hash["receipt"]),
+        credit_estimate: CreditEstimate.from_hash(hash["credit_estimate"])
+      )
+    end
+  end
+
+  DiscoveredTool = Struct.new(:name, :description, :input_schema, :score, :integration, :server, keyword_init: true) do
+    def self.from_hash(hash)
+      hash = hash.transform_keys(&:to_s)
+      # DG returns "tool_name" (not "name") and "input_contract" (not "input_schema")
+      new(
+        name: hash["tool_name"] || hash["name"],
+        description: hash["description"],
+        input_schema: hash["input_contract"] || hash["input_schema"] || hash["inputSchema"],
+        score: hash["score"]&.to_f,
+        integration: hash["integration"],
+        server: hash["server"]
+      )
+    end
+  end
+
+  DiscoverResult = Struct.new(:tools, :query, :total, keyword_init: true) do
+    def self.from_hash(hash)
+      hash = hash.transform_keys(&:to_s)
+      # DG returns "results" (not "tools") and "goal_used" (not "query")
+      tools_raw = hash["results"] || hash["tools"] || []
+      tools = tools_raw.map { |t| DiscoveredTool.from_hash(t) }
+      new(
+        tools: tools,
+        query: hash["goal_used"] || hash["query"],
+        total: hash["total"] || tools.size
+      )
+    end
+  end
+
+  GuideOption = Struct.new(:id, :label, :description, keyword_init: true) do
+    def self.from_hash(hash)
+      hash = hash.transform_keys(&:to_s)
+      new(id: hash["id"], label: hash["label"], description: hash["description"])
+    end
+  end
+
+  GuideState = Struct.new(:session_id, :status, :options, :result, :step, keyword_init: true) do
+    def self.from_hash(hash)
+      hash = hash.transform_keys(&:to_s)
+      opts = hash["options"]&.map { |o| GuideOption.from_hash(o) }
+      new(
+        session_id: hash["session_id"] || hash["sessionId"],
+        status: hash["status"],
+        options: opts,
+        result: hash["result"],
+        step: hash["step"]
+      )
+    end
+  end
+end

data/lib/datagrout_conduit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  VERSION = "0.1.0"
+end

data/lib/datagrout_conduit.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "datagrout_conduit/version"
+require_relative "datagrout_conduit/errors"
+require_relative "datagrout_conduit/types"
+require_relative "datagrout_conduit/identity"
+require_relative "datagrout_conduit/oauth"
+require_relative "datagrout_conduit/registration"
+require_relative "datagrout_conduit/transport/base"
+require_relative "datagrout_conduit/transport/mcp"
+require_relative "datagrout_conduit/transport/jsonrpc"
+require_relative "datagrout_conduit/client"
+
+module DatagroutConduit
+  DG_CA_URL = Registration::DG_CA_URL
+  DG_SUBSTRATE_ENDPOINT = Registration::DG_SUBSTRATE_ENDPOINT
+
+  # Returns true when +url+ points at a DataGrout-managed endpoint.
+  #
+  # Used to decide whether to auto-enable mTLS discovery and the intelligent
+  # interface, and whether to warn when DG-specific methods are called against
+  # a non-DG server.
+  def self.dg_url?(url)
+    url.to_s.include?("datagrout.ai") ||
+      url.to_s.include?("datagrout.dev") ||
+      ENV.key?("CONDUIT_IS_DG")
+  end
+
+  # Extract the DataGrout metadata block from a tool-call result.
+  #
+  # Checks +_meta.datagrout+ first (current format), then +_datagrout+,
+  # then falls back to +_meta+ for backward compatibility with older
+  # gateway responses.
+  #
+  # Returns nil when the result contains neither key (e.g. upstream servers
+  # that don't go through the DG gateway).
+  #
+  #   meta = DatagroutConduit.extract_meta(result)
+  #   meta.receipt.net_credits  #=> 1.5
+  #   meta.receipt.receipt_id   #=> "rcp_abc123"
+  def self.extract_meta(result)
+    return nil unless result.is_a?(Hash)
+
+    raw = result.dig("_meta", "datagrout") || result.dig(:_meta, :datagrout) ||
+          result["_datagrout"] || result[:_datagrout] ||
+          result["_meta"] || result[:_meta]
+    return nil if raw.nil?
+
+    ToolMeta.from_hash(raw)
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: datagrout-conduit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- DataGrout
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Production-ready MCP client with mTLS, OAuth 2.1, and semantic discovery.
+  Connect to remote MCP and JSONRPC servers, invoke tools, discover capabilities with
+  natural language, and track costs — all with enterprise-grade security.
+email:
+- hello@datagrout.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/datagrout_conduit.rb
+- lib/datagrout_conduit/client.rb
+- lib/datagrout_conduit/errors.rb
+- lib/datagrout_conduit/identity.rb
+- lib/datagrout_conduit/oauth.rb
+- lib/datagrout_conduit/registration.rb
+- lib/datagrout_conduit/transport/base.rb
+- lib/datagrout_conduit/transport/jsonrpc.rb
+- lib/datagrout_conduit/transport/mcp.rb
+- lib/datagrout_conduit/types.rb
+- lib/datagrout_conduit/version.rb
+homepage: https://github.com/DataGrout/conduit-sdk
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/DataGrout/conduit-sdk
+  source_code_uri: https://github.com/DataGrout/conduit-sdk/tree/main/ruby
+  changelog_uri: https://github.com/DataGrout/conduit-sdk/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/DataGrout/conduit-sdk/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Production-ready MCP client with mTLS, OAuth 2.1, and semantic discovery
+test_files: []