omniai 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90c0c98df3552c3e1351671ebf9d02847f96a4cf8c92163a25cd1e119d3b3e7d
-  data.tar.gz: 509907dabedafa041381621aea668747547cd60da6edd78d9fdfd325c224c1a5
+  metadata.gz: e0d7be9d7a666bdabc7c18e8ce6b090e5c69622d469d3444278a5054a82fab92
+  data.tar.gz: c6a0aaf46493811c8210ac1a8bec5dcb1999094dc38edd4f5fee3fdc489f554d
 SHA512:
-  metadata.gz: e96e2441296a6283ce5bfe9f3025c2a3838466d1f2c44ff4bc95f1f4b84a7dd7559c227f909382e7d01fb676b13eb344b3b164c0c96e0963b52bf377c2bb73d8
-  data.tar.gz: bcc1d3f357c57c010b0064ba2e2becc74df572263d9378351a22d0a9f17b4fa3336b9645e7f221a78d620d72a2afe2c922f2f337b56f6c955a752e7188457f38
+  metadata.gz: 277b89d8176066963f4c6401eedd1397539789b8dc148ddbd6332d42a8e109ccf2f862f0f5257913075695911c7c7e4c2aa0d863cd5a471166a1e0835bd3f08d
+  data.tar.gz: 00b867d114d24be9ddf474e8ace64bbf6ae662737527cdd9fe27ea69941bbea082c505581dd781fb56b6eba03980b77580e0d4eeaf6caeca4174c0e376341236

data/README.md

@@ -530,3 +530,44 @@ Type 'exit' or 'quit' to abort.
 0.0
 ...
 ```
+
+### MCP
+
+[MCP](https://modelcontextprotocol.io/introduction) is an open protocol designed to standardize giving context to LLMs. The OmniAI implementation supports building an MCP server that operates via the [stdio](https://modelcontextprotocol.io/docs/concepts/transports) transport.
+
+**main.rb**
+
+```ruby
+class Weather < OmniAI::Tool
+  description "Lookup the weather for a location"
+
+  parameter :location, :string, description: "A location (e.g. 'London' or 'Madrid')."
+  required %i[location]
+
+  # @param location [String] required
+  # @return [String]
+  def execute(location:)
+    case location
+    when 'London' then 'Rainy'
+    when 'Madrid' then 'Sunny'
+    end
+  end
+end
+
+transport = OmniAI::MCP::Transport::Stdio.new
+mcp = OmniAI::MCP::Server.new(tools: [Weather.new])
+mcp.run(transport:)
+```
+
+```bash
+ruby main.rb
+```
+
+```bash
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "tools/call",
+  "params": { "name": "echo", "arguments": { "message": "Hello, world!" } }
+}
+```

data/lib/omniai/chat/content.rb

@@ -25,7 +25,7 @@ module OmniAI
       # @return [Content]
       def self.deserialize(data, context: nil)
         return data if data.nil?
-        return data.map { |data| deserialize(data, context:) } if data.is_a?(Array)
+        return data.map { |entry| deserialize(entry, context:) } if data.is_a?(Array)
 
         deserialize = context&.deserializer(:content)
         return deserialize.call(data, context:) if deserialize

data/lib/omniai/chat.rb

@@ -109,6 +109,11 @@ module OmniAI
 
   protected
 
+    # @return [Boolean]
+    def stream?
+      !@stream.nil?
+    end
+
     # Override  to provide an context for serializers / deserializes for a provider.
     #
     # @return [Context, nil]
@@ -151,7 +156,7 @@ module OmniAI
     #
     # @return [OmniAI::Chat::Response]
     def parse!(response:)
-      if @stream
+      if stream?
         stream!(response:)
       else
         complete!(response:)

data/lib/omniai/mcp/jrpc/error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    module JRPC
+      # @example
+      #   raise OmniAI::MCP::JRPC::Error.new(code: OmniAI::MCP::JRPC::Error::PARSE_ERROR, message: "Invalid JSON")
+      class Error < StandardError
+        module Code
+          PARSE_ERROR = -32_700
+          INVALID_REQUEST = -32_600
+          METHOD_NOT_FOUND = -32_601
+          INVALID_PARAMS = -32_602
+          INTERNAL_ERROR = -32_603
+        end
+
+        # @!attribute [r] code
+        #   @return [Integer]
+        attr_accessor :code
+
+        # @!attribute [r] message
+        #   @return [String]
+        attr_accessor :message
+
+        # @param code [Integer]
+        # @param message [String]
+        def initialize(code:, message:)
+          super("code=#{code} message=#{message}")
+
+          @code = code
+          @message = message
+        end
+      end
+    end
+  end
+end

data/lib/omniai/mcp/jrpc/request.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    module JRPC
+      # @example
+      #   request = OmniAI::MCP::JRPC::Request.new(id: 0, method: "ping", params: {})
+      #   request.id #=> 0
+      #   request.method #=> "ping"
+      #   request.params #=> {}
+      class Request
+        # @!attribute [rw] id
+        #   @return [Integer]
+        attr_accessor :id
+
+        # @!attribute [rw] method
+        #   @return [String]
+        attr_accessor :method
+
+        # @!attribute [rw] params
+        #   @return [Hash]
+        attr_accessor :params
+
+        # @param id [Integer]
+        # @param method [String]
+        # @param params [Hash]
+        def initialize(id:, method:, params:)
+          @id = id
+          @method = method
+          @params = params
+        end
+
+        # @return [String]
+        def inspect
+          "#<#{self.class.name} id=#{@id} method=#{@method} params=#{@params}>"
+        end
+
+        # @return [String]
+        def generate
+          JSON.generate({
+            jsonrpc: VERSION,
+            id: @id,
+            method: @method,
+            params: @params,
+          })
+        end
+
+        # @param text [String]
+        #
+        # @raise [OmniAI::MCP::JRPC::Error]
+        #
+        # @return [OmniAI::MCP::JRPC::Request]
+        def self.parse(text)
+          data =
+            begin
+              JSON.parse(text)
+            rescue JSON::ParserError => e
+              raise Error.new(code: Error::Code::PARSE_ERROR, message: e.message)
+            end
+
+          id = data["id"] || raise(Error.new(code: Error::Code::PARSE_ERROR, message: "missing id"))
+          method = data["method"] || raise(Error.new(code: Error::Code::PARSE_ERROR, message: "missing method"))
+          params = data["params"] || raise(Error.new(code: Error::Code::PARSE_ERROR, message: "missing params"))
+
+          new(id:, method:, params:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/mcp/jrpc/response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    module JRPC
+      # @example
+      #   request = OmniAI::MCP::JRPC::Response.new(id: 0, result: "OK")
+      #   request.generate #=> { "jsonrpc": "2.0", "id": 0, "result": "OK" }
+      class Response
+        # @!attribute [rw] id
+        #   @return [Integer]
+        attr_accessor :id
+
+        # @!attribute [rw] result
+        #   @return [String]
+        attr_accessor :result
+
+        # @param id [Integer]
+        # @param result [String]
+        def initialize(id:, result:)
+          @id = id
+          @result = result
+        end
+
+        # @return [String]
+        def inspect
+          "#<#{self.class.name} id=#{@id} result=#{@result}>"
+        end
+
+        # @return [String]
+        def generate
+          JSON.generate({
+            jsonrpc: VERSION,
+            id: @id,
+            result: @result,
+          })
+        end
+
+        # @param text [String]
+        #
+        # @raise [OmniAI::MCP::JRPC::Error]
+        #
+        # @return [OmniAI::MCP::JRPC::Response]
+        def self.parse(text)
+          data =
+            begin
+              JSON.parse(text)
+            rescue JSON::ParserError => e
+              raise Error.new(code: Error::Code::PARSE_ERROR, message: e.message)
+            end
+
+          id = data["id"] || raise(Error.new(code: Error::Code::PARSE_ERROR, message: "missing id"))
+          result = data["result"] || raise(Error.new(code: Error::Code::PARSE_ERROR, message: "missing result"))
+
+          new(id:, result:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/mcp/jrpc.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    # @example
+    #   OmniAI::MCP::JRPC::VERSION
+    module JRPC
+      VERSION = "2.0"
+    end
+  end
+end

data/lib/omniai/mcp/server.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    # @example
+    #   server = OmniAI::MCP::Server.new(tools: [...])
+    #   server.run
+    class Server
+      PROTOCOL_VERSION = "2025-03-26"
+
+      # @param tools [Array<OmniAI::Tool>]
+      # @param logger [Logger, nil]
+      def initialize(tools:, logger: nil, name: "OmniAI", version: OmniAI::VERSION)
+        @tools = tools
+        @logger = logger
+        @name = name
+        @version = version
+      end
+
+      # @param transport [OmniAI::MCP::Transport]
+      def run(transport: OmniAI::MCP::Transport::Stdio.new)
+        loop do
+          message = transport.gets
+          break if message.nil?
+
+          @logger&.info("#{self.class}#run: message=#{message.inspect}")
+          response = process(message)
+          @logger&.info("#{self.class}#run: response=#{response.inspect}")
+
+          transport.puts(response) if response
+        end
+      end
+
+    private
+
+      # @param message [String]
+      #
+      # @return [String, nil]
+      def process(message)
+        request = JRPC::Request.parse(message)
+
+        response =
+          case request.method
+          when "initialize" then process_initialize(request:)
+          when "ping" then process_ping(request:)
+          when "tools/list" then process_tools_list(request:)
+          when "tools/call" then process_tools_call(request:)
+          end
+
+        response&.generate if response&.result
+      rescue JRPC::Error => e
+        JSON.generate({
+          jsonrpc: JRPC::VERSION,
+          id: request&.id,
+          error: {
+            code: e.code,
+            message: e.message,
+          },
+        })
+      end
+
+      # @param request [JRPC::Request]
+      # @return [JRPC::Response]
+      def process_initialize(request:)
+        JRPC::Response.new(id: request.id, result: {
+          protocolVersion: PROTOCOL_VERSION,
+          serverInfo: {
+            name: @name,
+            version: @version,
+          },
+          capabilities: {},
+        })
+      end
+
+      # @param request [JRPC::Request]
+      # @return [JRPC::Response]
+      def process_ping(request:)
+        JRPC::Response.new(id: request.id, result: {})
+      end
+
+      # @param request [JRPC::Request]
+      #
+      # @raise [JRPC::Error]
+      #
+      # @return [JRPC::Response]
+      def process_tools_list(request:)
+        result = @tools.map do |tool|
+          {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.parameters.serialize,
+          }
+        end
+
+        JRPC::Response.new(id: request.id, result:)
+      end
+
+      # @param request [JRPC::Request]
+      #
+      # @raise [JRPC::Error]
+      #
+      # @return [JRPC::Response]
+      def process_tools_call(request:)
+        name = request.params["name"]
+        tool = @tools.find { |tool| tool.name.eql?(name) }
+
+        result =
+          begin
+            tool.call(request.params["input"])
+          rescue StandardError => e
+            raise JRPC::Error.new(code: JRPC::Error::Code::INTERNAL_ERROR, message: e.message)
+          end
+
+        JRPC::Response.new(id: request.id, result:)
+      end
+    end
+  end
+end

data/lib/omniai/mcp/transport/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    module Transport
+      # @example
+      #   transport = OmniAI::MCP::Transport::Base.new
+      #   transport.puts("Hello World")
+      #   transport.gets
+      class Base
+        # @param text [String]
+        def puts(text)
+          raise NotImplementedError, "#{self.class}#gets undefined"
+        end
+
+        # @return [String]
+        def gets
+          raise NotImplementedError, "#{self.class}#gets undefined"
+        end
+      end
+    end
+  end
+end

data/lib/omniai/mcp/transport/stdio.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module MCP
+    module Transport
+      # @example
+      #   transport = OmniAI::MCP::Transport::Stdio.new
+      #   transport.puts("Hello World")
+      #   transport.gets
+      class Stdio < Base
+        # @param stdin [IO]
+        # @param stdout [IO]
+        # @param stderr [IO]
+        def initialize(stdin: $stdin, stdout: $stdout, stderr: $stderr)
+          super()
+          @stdin = stdin
+          @stdout = stdout
+          @stderr = stderr
+        end
+
+        # @param text [String]
+        def puts(text)
+          @stdout.puts(text)
+        end
+
+        # @return [String]
+        def gets
+          @stdin.gets
+        end
+      end
+    end
+  end
+end

data/lib/omniai/tool.rb

@@ -72,7 +72,7 @@ module OmniAI
     # @param function [Proc]
     # @param name [String]
     # @param description [String]
-    # @param parameters [Hash]
+    # @param parameters [OmniAI::Tool::Parameters]
     def initialize(
       function = method(:execute),
       name: self.class.namify,

data/lib/omniai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OmniAI
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/lib/omniai.rb

@@ -8,8 +8,10 @@ require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect "omniai" => "OmniAI"
-loader.inflector.inflect "url" => "URL"
 loader.inflector.inflect "cli" => "CLI"
+loader.inflector.inflect "jrpc" => "JRPC"
+loader.inflector.inflect "mcp" => "MCP"
+loader.inflector.inflect "url" => "URL"
 loader.setup
 
 module OmniAI

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: omniai
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 bindir: exe
 cert_chain: []
-date: 2025-03-24 00:00:00.000000000 Z
+date: 2025-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -111,6 +111,13 @@ files:
 - lib/omniai/embed/usage.rb
 - lib/omniai/files.rb
 - lib/omniai/instrumentation.rb
+- lib/omniai/mcp/jrpc.rb
+- lib/omniai/mcp/jrpc/error.rb
+- lib/omniai/mcp/jrpc/request.rb
+- lib/omniai/mcp/jrpc/response.rb
+- lib/omniai/mcp/server.rb
+- lib/omniai/mcp/transport/base.rb
+- lib/omniai/mcp/transport/stdio.rb
 - lib/omniai/speak.rb
 - lib/omniai/tool.rb
 - lib/omniai/tool/array.rb