ruboty-ai_agent 0.1.0

data/lib/ruboty/ai_agent/commands.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Interaction commands (a.k.a. Slash commands, Prompts, etc)
+    module Commands
+      autoload :Base, 'ruboty/ai_agent/commands/base'
+      autoload :Clear, 'ruboty/ai_agent/commands/clear'
+      autoload :Compact, 'ruboty/ai_agent/commands/compact'
+      autoload :Usage, 'ruboty/ai_agent/commands/usage'
+
+      # @rbs message: Ruboty::Message
+      # @rbs chat_thread: ChatThread
+      # @rbs return: Array[Commands::Base]
+      def self.builtins(message:, chat_thread:)
+        [
+          Commands::Clear.new(
+            message:,
+            chat_thread:
+          ),
+          Commands::Compact.new(
+            message:,
+            chat_thread:
+          ),
+          Commands::Usage.new(
+            message:,
+            chat_thread:
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/database/query_methods.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    class Database
+      # @rbs!
+      #   interface _WithData
+      #     def data: -> Hash[keynable, untyped]
+      #   end
+
+      # @rbs module-self _WithData
+      module QueryMethods
+        # @rbs *keys: keynable
+        # @rbs return: untyped
+        def fetch(*keys)
+          item = data.dig(*keys)
+
+          Recordable.instantiate_recursively(item)
+        end
+
+        # @rbs *keys: keynable
+        # @rbs return: Integer
+        def len(*keys)
+          item = data.dig(*keys)
+          item.respond_to?(:length) ? item.length : 0
+        end
+
+        # @rbs *keys: keynable
+        # @rbs return: void
+        def delete(*keys)
+          namespace_keys = keys[0..-2] || []
+          key = keys[-1]
+
+          namespace = namespace_keys.empty? ? data : data.dig(*namespace_keys) #: top
+          case namespace
+          when Hash
+            namespace.delete(key)
+          when Array
+            namespace.delete_at(key) if key.is_a?(Integer) && key < namespace.length
+          end
+        end
+
+        # @rbs *keys: keynable
+        # @rbs return: Array[keynable]
+        def keys(*keys)
+          namespace = keys.empty? ? data : data.dig(*keys) #: top
+          case namespace
+          when Hash
+            namespace.keys
+          when Array
+            namespace.length.times.to_a
+          else
+            []
+          end
+        end
+
+        # @rbs *keys: keynable
+        # @rbs return: boolish
+        def key?(*keys)
+          namespace_keys = keys[0..-2] || []
+          key = keys[-1]
+
+          namespace = namespace_keys.empty? ? data : data.dig(*namespace_keys)
+          namespace&.key?(key)
+        end
+
+        # @rbs at: Array[keynable]
+        # @rbs value: untyped
+        # @rbs return: void
+        def store(value, at:)
+          namespace_keys = at[0..-2] || []
+          key = at[-1]
+
+          namespace = namespace_keys.reduce(data) do |current, k|
+            current[k] ||= {}
+            current[k]
+          end
+
+          namespace[key] = Recordable.hashify_recursively(value)
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/database.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Memorize and retrieve information using Ruboty's brain.
+    class Database
+      # @rbs!
+      #   type keynable = Symbol | String | Integer
+
+      autoload :QueryMethods, 'ruboty/ai_agent/database/query_methods'
+
+      include QueryMethods
+
+      NAMESPACE = :ai_agent
+
+      attr_reader :brain #: Ruboty::Brains::Base
+
+      # @rbs brain: Ruboty::Brains::Base
+      def initialize(brain)
+        @brain = brain
+      end
+
+      def data #: Hash[keynable, untyped]
+        brain.data[NAMESPACE] ||= {} # steep:ignore UnannotatedEmptyCollection
+      end
+
+      def user(id) #: User
+        User.find_or_create(database: self, id: id)
+      end
+
+      def chat_thread(id) #: ChatThread
+        ChatThread.find_or_create(database: self, id: id)
+      end
+
+      def global_settings #: GlobalSettings
+        @global_settings ||= GlobalSettings.find_or_create(database: self)
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/global_settings.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Global settings for AI agent.
+    class GlobalSettings
+      attr_reader :database #: Ruboty::AiAgent::Database
+
+      NAMESPACE_KEYS = [:global_settings].freeze #: Array[Database::keynable]
+
+      class << self
+        def find_or_create(database:) #: GlobalSettings
+          new(database: database)
+        end
+      end
+
+      # @rbs database: Ruboty::AiAgent::Database
+      def initialize(database:)
+        @database = database
+      end
+
+      def system_prompt #: String?
+        database.fetch(*NAMESPACE_KEYS, :system_prompt)
+      end
+
+      # @rbs prompt: String?
+      # @rbs return: void
+      def system_prompt=(prompt)
+        database.store(prompt, at: [*NAMESPACE_KEYS, :system_prompt])
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/http_mcp_client.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'securerandom'
+require 'event_stream_parser'
+
+module Ruboty
+  module AiAgent
+    # Mcp client with HTTP transport.
+    class HttpMcpClient
+      attr_reader :base_url, :headers, :session_id
+
+      def initialize(url:, headers: {}, session_id: nil)
+        @base_url = url
+        @headers = headers
+        @session_id = session_id
+
+        @initialize_called = false
+      end
+
+      def initialize_session
+        response = send_request(
+          method: 'initialize',
+          params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {}, #: Hash[untyped, untyped]
+            clientInfo: {
+              name: 'ruboty-ai_agent',
+              version: '1.0'
+            }
+          }
+        ).first
+
+        @session_id = response['Mcp-Session-Id'] if response.is_a?(Hash) && response['Mcp-Session-Id']
+        @initialize_called = true
+        @session_id
+      end
+
+      def ping
+        ensure_initialized
+        send_request(method: 'ping')
+      end
+
+      def list_tools
+        ensure_initialized
+        results = send_request(method: 'tools/list')
+        results.flat_map { |res| res.dig('result', 'tools') || [] }
+      end
+
+      # @rbs name: String
+      # @rbs &block: ? (Hash[String, untyped]) -> void
+      def call_tool(name, arguments = {}, &block)
+        ensure_initialized
+        results = send_request(
+          method: 'tools/call',
+          params: {
+            name: name,
+            arguments: arguments
+          },
+          &block
+        )
+
+        results.flat_map { |res| res.dig('result', 'content') || [] }
+      end
+
+      def list_prompts
+        ensure_initialized
+        send_request(method: 'prompts/list')
+      end
+
+      def get_prompt(name, arguments = {})
+        ensure_initialized
+        send_request(
+          method: 'prompts/get',
+          params: {
+            name: name,
+            arguments: arguments
+          }
+        )
+      end
+
+      def list_resources
+        ensure_initialized
+        send_request(method: 'resources/list')
+      end
+
+      def read_resource(uri)
+        ensure_initialized
+        send_request(
+          method: 'resources/read',
+          params: {
+            uri: uri
+          }
+        )
+      end
+
+      def cleanup_session
+        if @session_id
+          uri = URI.parse(@base_url)
+
+          raise 'Invalid uri' if uri.host.nil?
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == 'https'
+
+          request = Net::HTTP::Delete.new(uri.path.nil? || uri.path.empty? ? '/' : uri.path)
+          request['Accept'] = 'application/json, text/event-stream'
+          request['Content-Type'] = 'application/json'
+          request['Mcp-Session-Id'] = @session_id
+          headers.each { |k, v| request[k] = v }
+
+          http.request(request)
+          @session_id = nil
+        end
+
+        @initialize_called = false
+      end
+
+      private
+
+      # @rbs @initialize_called: bool
+
+      def ensure_initialized
+        return if @initialize_called || @session_id
+
+        initialize_session
+      end
+
+      # @rbs method: String
+      # @rbs ?params: Hash[String | Symbol, untyped]?
+      # @rbs ?id: String?
+      # @rbs &block: ? (Hash[String, untyped]) -> void
+      # @rbs return: Array[Hash[String, untyped]]
+      def send_request(method:, params: nil, id: nil, &block)
+        uri = URI.parse(@base_url)
+
+        raise 'Invalid uri' if uri.host.nil?
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+
+        request = Net::HTTP::Post.new(uri.path.nil? || uri.path.empty? ? '/' : uri.path)
+        request['Accept'] = 'application/json, text/event-stream'
+        request['Content-Type'] = 'application/json'
+        request['Mcp-Session-Id'] = @session_id if @session_id
+        headers.each { |k, v| request[k] = v }
+
+        body = {
+          jsonrpc: '2.0',
+          method: method,
+          id: id || SecureRandom.uuid
+        } #: Hash[Symbol, untyped]
+        body[:params] = params if params
+
+        request.body = JSON.generate(body)
+
+        response = http.request(request)
+        raise Error, "HTTP #{response.code}: #{response.body}" unless response.code.to_i == 200
+
+        @session_id = response['Mcp-Session-Id'] if method == 'initialize'
+
+        if response['Content-Type'] =~ %r{text/event-stream}
+          handle_streaming_response(response, &block)
+        else
+          handle_response(response, &block)
+        end
+      end
+
+      # @rbs response: Net::HTTPResponse
+      # @rbs &block: ? (Hash[String, untyped]) -> void
+      # @rbs return: Array[Hash[String, untyped]]
+      def handle_response(response, &block)
+        result = JSON.parse(response.body)
+
+        raise Error, "JSON-RPC Error #{result['error']['code']}: #{result['error']['message']}" if result['error']
+
+        result['Mcp-Session-Id'] = response['Mcp-Session-Id'] if response['Mcp-Session-Id']
+
+        block&.call(result)
+
+        [result]
+      end
+
+      # @rbs response: Net::HTTPResponse
+      # @rbs &block: ? (Hash[String, untyped]) -> void
+      # @rbs return: Array[Hash[String, untyped]]
+      def handle_streaming_response(response, &block)
+        events = [] #: Array[Hash[String, untyped]]
+        parser = EventStreamParser::Parser.new
+
+        body = response.body
+        parser.feed(body) do |_type, data, _id, _reconnection_time|
+          next if data.nil? || data.empty?
+
+          begin
+            parsed_data = JSON.parse(data)
+            raise Error, "JSON-RPC Error #{parsed_data['error']['code']}: #{parsed_data['error']['message']}" if parsed_data['error']
+
+            block&.call(parsed_data)
+
+            events << parsed_data
+          rescue JSON::ParserError => e
+            raise Error, "Failed to parse SSE data: #{e.message}"
+          end
+        end
+
+        events
+      end
+
+      class Error < StandardError; end
+    end
+  end
+end

data/lib/ruboty/ai_agent/llm/openai/model.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module LLM
+      class OpenAI
+        # Model information and token limit estimation
+        class Model
+          attr_reader :name #: String
+
+          # @rbs name: String
+          def initialize(name)
+            @name = name
+          end
+
+          # Estimate token limit based on model name
+          # @rbs return: Integer
+          def token_limit
+            if name.include?('gpt-5')
+              400_000
+            else
+              128_000
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/llm/openai.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'openai'
+
+module Ruboty
+  module AiAgent
+    module LLM
+      # LLM interface for OpenAI's chat completion API.
+      class OpenAI
+        autoload :Model, 'ruboty/ai_agent/llm/openai/model'
+        attr_reader :client #: OpenAI::Client
+        attr_reader :model #: String
+
+        # @rbs client: OpenAI::Client
+        # @rbs model: String
+        def initialize(client:, model:)
+          @client = client
+          @model = model
+        end
+
+        # @rbs %a{memorized}
+        def model_info #: Model
+          @model_info ||= Model.new(model)
+        end
+
+        # @rbs messages: Array[ChatMessage]
+        # @rbs tools: Array[Tool]
+        # @rbs return: Response
+        def complete(messages:, tools: [])
+          openai_response = client.chat.completions.create(
+            model:,
+            messages: openai_messages_from_messages(messages), #: untyped
+            tools: openai_tools_from_tools(tools)
+          )
+
+          to_response(openai_response:, tools:)
+        end
+
+        private
+
+        # @rbs!
+        #   type tool_call = {
+        #     id: String,
+        #     type: 'function',
+        #     function: { name: String, arguments: String }
+        #   }
+
+        # @rbs!
+        #   type system_message = { role: 'system', content: String }
+        #   type user_message = { role: 'user', content: String }
+        #   type assistant_message = { role: 'assistant', content: String, tool_calls: Array[tool_call]? }
+        #   type tool_message = { role: 'tool', tool_call_id: String, content: String }
+        #   type message = system_message | user_message | assistant_message | tool_message
+
+        # @rbs messages: Array[ChatMessage]
+        # @rbs return: Array[OpenAI::Models::Chat::chat_completion_message_param]
+        def openai_messages_from_messages(messages)
+          messages.map do |message|
+            case message.role.to_sym
+            when :system
+              ::OpenAI::Models::Chat::ChatCompletionSystemMessageParam.new(
+                role: :system, content: message.content
+              )
+            when :user
+              ::OpenAI::Models::Chat::ChatCompletionUserMessageParam.new(
+                role: :user, content: message.content
+              )
+              # { role: 'user', content: message.content } #: user_message
+            when :assistant
+              if message.tool_call_id
+                tool_calls = [
+                  ::OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall.new(
+                    id: message.tool_call_id,
+                    type: :function,
+                    function: ::OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall::Function.new(
+                      name: message.tool_name || 'unknown_tool',
+                      arguments: message.tool_arguments.to_json
+                    )
+                  )
+                ]
+              end
+
+              if tool_calls
+                ::OpenAI::Models::Chat::ChatCompletionAssistantMessageParam.new(
+                  role: :assistant,
+                  content: message.content,
+                  tool_calls: tool_calls
+                )
+              else
+                ::OpenAI::Models::Chat::ChatCompletionAssistantMessageParam.new(
+                  role: :assistant,
+                  content: message.content
+                )
+              end
+            when :tool
+              ::OpenAI::Models::Chat::ChatCompletionToolMessageParam.new(
+                role: :tool,
+                tool_call_id: message.tool_call_id || 'unknown_tool_call_id',
+                content: message.content
+              )
+            else
+              raise "Unknown message role: #{message.role}"
+            end
+          end
+        end
+
+        # @rbs tools: Array[Tool]
+        # @rbs return: Array[OpenAI::Models::Chat::chat_completion_tool]
+        def openai_tools_from_tools(tools)
+          tools.map do |tool|
+            ::OpenAI::Models::Chat::ChatCompletionFunctionTool.new(
+              type: :function,
+              function: ::OpenAI::FunctionDefinition.new(
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema || {
+                  type: 'object',
+                  properties: {}, #: Hash[untyped, untyped]
+                  required: [] #: Array[untyped]
+                }
+              )
+            )
+          end
+        end
+
+        # @rbs openai_response: OpenAI::Models::Chat::ChatCompletion
+        # @rbs tools: Array[Tool]
+        # @rbs return: Response
+        def to_response(openai_response:, tools:)
+          choice = openai_response.choices.first
+          tool_call = choice.message.tool_calls&.first
+
+          token_usage = if openai_response.usage
+                          TokenUsage.new(
+                            prompt_tokens: openai_response.usage.prompt_tokens,
+                            completion_tokens: openai_response.usage.completion_tokens,
+                            total_tokens: openai_response.usage.total_tokens,
+                            token_limit: model_info.token_limit
+                          )
+                        end
+
+          if tool_call
+            tool = tools.find do |t|
+              if tool_call.type == :function
+                function_name =
+                  tool_call #: OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall
+                  .function.name
+                t.name == function_name
+              else
+                false
+              end
+            end
+          end
+
+          tool_arguments =
+            if tool_call && tool_call.type == :function
+              arguments =
+                tool_call #: OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall
+                .function.arguments
+
+              JSON.parse(arguments, { symbolize_names: true })
+            end
+
+          Response.new(
+            message: ChatMessage.new(
+              role: choice.message.role,
+              content: choice.message.content || '',
+              tool_call_id: tool_call&.id,
+              tool_name: tool&.name,
+              tool_arguments:,
+              token_usage:
+            ),
+            tool:,
+            tool_call_id: tool_call&.id,
+            tool_arguments:
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/llm/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module LLM
+      Response = Data.define(
+        :message, #: ChatMessage
+        :tool, #: Ruboty::AiAgent::Tool?
+        :tool_call_id, #: String?
+        :tool_arguments #: Hash[String, String]?
+      )
+
+      # General response class for LLM interactions.
+      class Response
+        def call_tool #: String?
+          tool&.call(tool_arguments)
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/llm.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # LLM-related backends and its utilities.
+    module LLM
+      autoload :OpenAI, 'ruboty/ai_agent/llm/openai'
+      autoload :Response, 'ruboty/ai_agent/llm/response'
+    end
+  end
+end

data/lib/ruboty/ai_agent/mcp_clients.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Manages multiple MCP (Model Context Protocol) clients
+    class McpClients
+      attr_reader :clients #: Array[UserMcpClient]
+
+      # @rbs clients: Array[UserMcpClient]
+      def initialize(clients)
+        @clients = clients
+      end
+
+      # @rbs return: Array[Tool]
+      def available_tools
+        clients.flat_map do |client|
+          tool_defs = client.list_tools
+          tool_defs.map do |tool_def|
+            Tool.new(
+              name: tool_def['name'],
+              title: tool_def['title'] || '',
+              description: tool_def['description'] || '',
+              input_schema: tool_def['inputSchema']
+            ) do |params|
+              client.call_tool(tool_def['name'], params).to_json
+            end
+          end
+        end
+      end
+
+      # @rbs function_name: String
+      # @rbs arguments: Hash[String, untyped]
+      # @rbs return: untyped
+      def execute_tool(function_name, arguments)
+        clients.each do |mcp_client|
+          tools = mcp_client.list_tools
+          return mcp_client.call_tool(function_name, arguments) if tools.any? { |t| t['name'] == function_name }
+        end
+        nil
+      end
+
+      # @rbs return: bool
+      def any?
+        @clients.any?
+      end
+    end
+  end
+end