rb-utcp 0.1.0

data/lib/utcp/providers/http_provider.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+require "uri"
+require "json"
+require "net/http"
+require_relative "../utils/subst"
+require_relative "../errors"
+require_relative "../tool"
+require_relative "../auth"
+require_relative "base_provider"
+
+module Utcp
+  module Providers
+    class HttpProvider < BaseProvider
+      def initialize(name:, url:, http_method: "GET", content_type: "application/json", headers: {}, manual: false, auth: nil, body_field: nil)
+        super(name: name, provider_type: manual ? "http_manual" : "http", auth: auth)
+        @url = Utils::Subst.apply(url)
+        @http_method = http_method.upcase
+        @content_type = content_type
+        @headers = Utils::Subst.apply(headers || {})
+        @manual = manual
+        @body_field = body_field
+      end
+
+      def discover_tools!
+        raise ProviderError, "Not a manual provider" unless @manual
+        uri = URI(@url)
+        req = Net::HTTP.const_get(@http_method.capitalize).new(uri)
+        headers = default_headers
+        apply_auth!(uri, headers)
+        headers.each { |k, v| req[k] = v }
+
+        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https")
+        begin
+          res = http.request(req)
+          raise ProviderError, "Manual fetch failed: #{res.code}" unless res.is_a?(Net::HTTPSuccess)
+          manual = JSON.parse(res.body)
+          to_tools(manual)
+        ensure
+          http.finish if http.active?
+        end
+      end
+
+      def call_tool(tool, arguments = {}, &block)
+        # tool.provider is a hash containing execution provider details
+        p = tool.provider
+        url = Utils::Subst.apply(p["url"] || @url)
+        method = (p["http_method"] || @http_method || "GET").upcase
+        content_type = p["content_type"] || @content_type || "application/json"
+        headers = Utils::Subst.apply(p["headers"] || {}).merge(default_headers)
+        body_field = p["body_field"] || @body_field
+
+        uri = URI(url)
+        args = Utils::Subst.apply(arguments || {})
+        if %w[GET DELETE].include?(method)
+          q = URI.decode_www_form(uri.query || "") + args.to_a
+          uri.query = URI.encode_www_form(q)
+          req = Net::HTTP.const_get(method.capitalize).new(uri)
+        else
+          req = Net::HTTP.const_get(method.capitalize).new(uri)
+          if body_field
+            payload = { body_field => args }
+          else
+            payload = args
+          end
+          if content_type.include?("json")
+            req.body = JSON.dump(payload)
+            req["Content-Type"] = "application/json"
+          else
+            req.body = URI.encode_www_form(payload)
+            req["Content-Type"] = "application/x-www-form-urlencoded"
+          end
+        end
+
+        # auth
+        headers = headers.transform_keys(&:to_s)
+        apply_auth!(uri, headers)
+        req["Cookie"] = [req["Cookie"], @auth&.apply_cookies].compact.join("; ") if @auth.respond_to?(:apply_cookies)
+        headers.each { |k, v| req[k] = v }
+
+        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https")
+        begin
+          res = http.request(req)
+          # try to parse as JSON; fall back to raw string
+          begin
+            JSON.parse(res.body)
+          rescue
+            res.body
+          end
+        ensure
+          http.finish if http.active?
+        end
+      end
+
+      private
+
+      def default_headers
+        { "User-Agent" => "ruby-utcp/#{Utcp::VERSION}" }.merge(@headers || {})
+      end
+
+      def apply_auth!(uri, headers)
+        if @auth
+          @auth.apply_query(uri) if @auth.respond_to?(:apply_query)
+          @auth.apply_headers(headers)
+        end
+      end
+
+      def to_tools(manual)
+        tools = (manual["tools"] || []).map do |t|
+          Utcp::Tool.new(
+            name: t["name"],
+            description: t["description"],
+            inputs: t["inputs"],
+            outputs: t["outputs"],
+            tags: t["tags"] || [],
+            provider: t["tool_provider"] || {}
+          )
+        end
+        tools
+      end
+    end
+  end
+end

data/lib/utcp/providers/http_stream_provider.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require "uri"
+require "net/http"
+require_relative "../utils/subst"
+require_relative "../errors"
+require_relative "base_provider"
+
+module Utcp
+  module Providers
+    # Simple HTTP chunked transfer streaming
+    class HttpStreamProvider < BaseProvider
+      def initialize(name:, auth: nil)
+        super(name: name, provider_type: "http_stream", auth: auth)
+      end
+
+      def discover_tools!
+        raise ProviderError, "HTTP stream is an execution provider only"
+      end
+
+      def call_tool(tool, arguments = {}, &block)
+        p = tool.provider
+        url = Utils::Subst.apply(p["url"])
+        method = (p["http_method"] || "GET").upcase
+        uri = URI(url)
+
+        args = Utils::Subst.apply(arguments || {})
+        if %w[GET DELETE].include?(method)
+          q = URI.decode_www_form(uri.query || "") + args.to_a
+          uri.query = URI.encode_www_form(q)
+        end
+
+        req = Net::HTTP.const_get(method.capitalize).new(uri)
+        headers = { "Accept" => "application/json" }
+        @auth&.apply_query(uri) if @auth&.respond_to?(:apply_query)
+        @auth&.apply_headers(headers)
+        headers.each { |k, v| req[k] = v }
+
+        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https")
+        begin
+          http.request(req) do |res|
+            res.read_body do |chunk|
+              yield chunk if block_given?
+            end
+          end
+          nil
+        ensure
+          http.finish if http.active?
+        end
+      end
+    end
+  end
+end

data/lib/utcp/providers/mcp_provider.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+require "uri"
+require "json"
+require "net/http"
+require_relative "../utils/subst"
+require_relative "../errors"
+require_relative "../auth"
+require_relative "../tool"
+require_relative "base_provider"
+
+module Utcp
+  module Providers
+    # Minimal HTTP-based MCP provider.
+    # Works in two modes:
+    #  - Manual discovery: GET {url}{discovery_path} returns a UTCP manual (tools array).
+    #  - Execution: POST {url}{call_path} with {"tool": name, "arguments": {...}}.
+    #
+    # Streaming:
+    #  - If the server replies with 'text/event-stream', we'll parse SSE 'data:' lines and yield them.
+    #  - Otherwise, if a block is given, chunks from the HTTP body are yielded as they arrive.
+    class McpProvider < BaseProvider
+      def initialize(name:, url:, headers: {}, auth: nil, manual: false, discovery_path: "/manual", call_path: "/call")
+        super(name: name, provider_type: manual ? "mcp_manual" : "mcp", auth: auth)
+        @url = Utils::Subst.apply(url)
+        @headers = Utils::Subst.apply(headers || {})
+        @manual = manual
+        @discovery_path = discovery_path
+        @call_path = call_path
+      end
+
+      def discover_tools!
+        raise ProviderError, "Not a manual provider" unless @manual
+        uri = URI(join_path(@url, @discovery_path))
+        req = Net::HTTP::Get.new(uri)
+        headers = default_headers
+        apply_auth!(uri, headers)
+        headers.each { |k, v| req[k] = v }
+
+        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https")
+        begin
+          res = http.request(req)
+          raise ProviderError, "MCP discovery failed: #{res.code}" unless res.is_a?(Net::HTTPSuccess)
+          manual = JSON.parse(res.body)
+          to_tools(manual)
+        ensure
+          http.finish if http.active?
+        end
+      end
+
+      # Expects tool.provider to include MCP endpoint info:
+      # { "provider_type": "mcp", "url": "http://host:port/mcp",
+      #   "call_path": "/call", "headers": { ... } }
+      def call_tool(tool, arguments = {}, &block)
+        p = tool.provider || {}
+        base = Utils::Subst.apply(p["url"] || @url)
+        call_path = p["call_path"] || @call_path
+        uri = URI(join_path(base, call_path))
+
+        body = { "tool" => tool.name, "arguments" => Utils::Subst.apply(arguments || {}) }
+        req = Net::HTTP::Post.new(uri)
+        headers = default_headers.merge({ "Content-Type" => "application/json" }).merge(Utils::Subst.apply(p["headers"] || {}))
+        apply_auth!(uri, headers)
+        headers.each { |k, v| req[k] = v }
+        req.body = JSON.dump(body)
+
+        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https")
+        begin
+          if block_given?
+            http.request(req) do |res|
+              ctype = (res["Content-Type"] || "").downcase
+              if ctype.include?("text/event-stream")
+                buffer = +""
+                res.read_body do |chunk|
+                  buffer << chunk
+                  while (line = buffer.slice!(/.*\n/))
+                    line = line.strip
+                    next if line.empty? || line.start_with?(":")
+                    if line.start_with?("data:")
+                      data = line.sub(/^data:\s?/, "")
+                      yield data
+                    end
+                  end
+                end
+              else
+                res.read_body do |chunk|
+                  yield chunk
+                end
+              end
+            end
+            nil
+          else
+            res = http.request(req)
+            begin
+              JSON.parse(res.body)
+            rescue
+              res.body
+            end
+          end
+        ensure
+          http.finish if http.active?
+        end
+      end
+
+      private
+
+      def default_headers
+        { "User-Agent" => "ruby-utcp/#{Utcp::VERSION}" }.merge(@headers || {})
+      end
+
+      def apply_auth!(uri, headers)
+        if @auth
+          @auth.apply_query(uri) if @auth.respond_to?(:apply_query)
+          @auth.apply_headers(headers)
+        end
+      end
+
+      def to_tools(manual)
+        (manual["tools"] || []).map do |t|
+          Utcp::Tool.new(
+            name: t["name"],
+            description: t["description"],
+            inputs: t["inputs"],
+            outputs: t["outputs"],
+            tags: t["tags"] || [],
+            provider: t["tool_provider"] || {}
+          )
+        end
+      end
+
+      def join_path(base, path)
+        return base.to_s if path.to_s.empty?
+        if base.end_with?("/")
+          base + path.sub(%r{^/}, "")
+        else
+          base + path
+        end
+      end
+    end
+  end
+end

data/lib/utcp/providers/sse_provider.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require "uri"
+require "net/http"
+require_relative "../utils/subst"
+require_relative "../errors"
+require_relative "base_provider"
+
+module Utcp
+  module Providers
+    # Execution provider for Server-Sent Events (SSE)
+    class SseProvider < BaseProvider
+      def initialize(name:, auth: nil)
+        super(name: name, provider_type: "sse", auth: auth)
+      end
+
+      # manual discovery not supported here
+      def discover_tools!
+        raise ProviderError, "SSE is an execution provider only"
+      end
+
+      # Expects tool.provider to have: { "url": "...", "http_method": "GET" }
+      def call_tool(tool, arguments = {}, &block)
+        p = tool.provider
+        url = Utils::Subst.apply(p["url"])
+        uri = URI(url)
+        # add args as query
+        args = Utils::Subst.apply(arguments || {})
+        q = URI.decode_www_form(uri.query || "") + args.to_a
+        uri.query = URI.encode_www_form(q)
+
+        req = Net::HTTP::Get.new(uri)
+        headers = { "Accept" => "text/event-stream" }
+        @auth&.apply_query(uri) if @auth&.respond_to?(:apply_query)
+        @auth&.apply_headers(headers)
+
+        headers.each { |k, v| req[k] = v }
+
+        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https")
+        begin
+          buffer = +""
+          http.request(req) do |res|
+            res.read_body do |chunk|
+              buffer << chunk
+              while (line = buffer.slice!(/.*\n/))
+                line = line.strip
+                next if line.empty? || line.start_with?(":")
+                if line.start_with?("data:")
+                  data = line.sub(/^data:\s?/, "")
+                  yield data if block_given?
+                end
+              end
+            end
+          end
+          nil
+        ensure
+          http.finish if http.active?
+        end
+      end
+    end
+  end
+end

data/lib/utcp/providers/tcp_provider.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require "socket"
+require_relative "../utils/subst"
+require_relative "../errors"
+require_relative "base_provider"
+
+module Utcp
+  module Providers
+    # Raw TCP provider
+    # tool.provider: { "provider_type":"tcp", "host":"127.0.0.1","port":5001,
+    #                  "message_template":"hello ${name}\n",
+    #                  "read_until":"\n", "timeout_ms": 2000 }
+    class TcpProvider < BaseProvider
+      def initialize(name:)
+        super(name: name, provider_type: "tcp", auth: nil)
+      end
+
+      def discover_tools!
+        raise ProviderError, "TCP is an execution provider only"
+      end
+
+      def call_tool(tool, arguments = {}, &block)
+        p = tool.provider
+        host = p["host"] || "127.0.0.1"
+        port = (p["port"] || 5001).to_i
+        timeout = (p["timeout_ms"] || 2000).to_i / 1000.0
+        msg = compose_message(p, arguments)
+
+        socket = TCPSocket.new(host, port)
+        begin
+          socket.write(msg) if msg
+          if block_given?
+            stream_read(socket, timeout: timeout) { |chunk| yield chunk }
+            nil
+          else
+            read_until = p["read_until"]
+            if read_until
+              read_until_delim(socket, read_until, timeout: timeout)
+            else
+              socket.read
+            end
+          end
+        ensure
+          socket.close rescue nil
+        end
+      end
+
+      private
+
+      def compose_message(p, arguments)
+        args = Utils::Subst.apply(arguments || {})
+        if p["message_template"]
+          tmpl = p["message_template"]
+          tmpl.gsub(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/) { |m| args[$1] || ENV[$1] || m }
+        else
+          nil
+        end
+      end
+
+      def stream_read(sock, timeout: 2)
+        loop do
+          ready = IO.select([sock], nil, nil, timeout)
+          break unless ready
+          chunk = sock.read_nonblock(4096, exception: false)
+          break unless chunk
+          yield chunk
+        end
+      end
+
+      def read_until_delim(sock, delim, timeout: 2)
+        buf = +"".b
+        loop do
+          ready = IO.select([sock], nil, nil, timeout)
+          break unless ready
+          c = sock.readpartial(1) rescue break
+          buf << c
+          break if buf.end_with?(delim)
+        end
+        buf
+      end
+    end
+  end
+end

data/lib/utcp/providers/udp_provider.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require "socket"
+require_relative "../utils/subst"
+require_relative "../errors"
+require_relative "base_provider"
+
+module Utcp
+  module Providers
+    # UDP provider (best-effort, may drop packets)
+    # tool.provider: { "provider_type":"udp", "host":"127.0.0.1","port":5002,
+    #                  "message_template":"ping ${name}", "timeout_ms": 1000, "max_bytes": 2048 }
+    class UdpProvider < BaseProvider
+      def initialize(name:)
+        super(name: name, provider_type: "udp", auth: nil)
+      end
+
+      def discover_tools!
+        raise ProviderError, "UDP is an execution provider only"
+      end
+
+      def call_tool(tool, arguments = {}, &block)
+        p = tool.provider
+        host = p["host"] || "127.0.0.1"
+        port = (p["port"] || 5002).to_i
+        timeout = (p["timeout_ms"] || 1000).to_i / 1000.0
+        max_bytes = (p["max_bytes"] || 2048).to_i
+        msg = compose_message(p, arguments)
+
+        udp = UDPSocket.new
+        udp.connect(host, port)
+        begin
+          udp.send(msg.to_s, 0)
+          if block_given?
+            if IO.select([udp], nil, nil, timeout)
+              data, _ = udp.recvfrom(max_bytes)
+              yield data
+            end
+            nil
+          else
+            if IO.select([udp], nil, nil, timeout)
+              data, _ = udp.recvfrom(max_bytes)
+              data
+            else
+              nil
+            end
+          end
+        ensure
+          udp.close rescue nil
+        end
+      end
+
+      private
+
+      def compose_message(p, arguments)
+        args = Utils::Subst.apply(arguments || {})
+        if p["message_template"]
+          tmpl = p["message_template"]
+          tmpl.gsub(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/) { |m| args[$1] || ENV[$1] || m }
+        else
+          ""
+        end
+      end
+    end
+  end
+end