smart_agent 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e36441cd494df0719fcfe3ecff04976392e091372706e04e65949c6d17f32e95
+  data.tar.gz: dabe51abbd3e8cb0b8184f042b32361a0a50fe9cbc4f7b86e8fa93b88ee222aa
+SHA512:
+  metadata.gz: '09335af182cc6402c814098f1de24dbf62e5ef5187fb6297c3f4b2b301e04d8b37e1da242b0d7bb0ea55d42722ca90c7ce451fbdd7d7832ff84dd1f1f6643751'
+  data.tar.gz: 910c95df53d2564bc1f842c56925866d8ac255365c9329e7113450dbb9fffd9d8221d51c3c72e3342c4bbfec0b33bf79642eeb736457b188c76f4025cf96c71a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 zhuangbiaowei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+# Smart Agent Framework
+
+[![Ruby Version](https://img.shields.io/badge/Ruby-3.2%2B-red)](https://www.ruby-lang.org)
+[![Gem Version](https://img.shields.io/gem/v/smart_agent)](https://rubygems.org/gems/smart_agent)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+An intelligent agent framework built on [smart_prompt](https://github.com/zhuangbiaowei/smart_prompt), featuring DSL definition, function calling and MCP protocol integration.
+
+## Key Features
+
+- **Declarative DSL** - Define agents and workflows using concise Ruby syntax
+- **Function Calling** - Seamless integration with LLM capabilities
+- **MCP Protocol** - Built-in Model Context Protocol support
+- **Task Orchestration** - Coordinate multiple agents for complex tasks
+- **Extensible Architecture** - Support custom functions and protocol handlers
+
+## Quick Start
+
+```ruby
+require 'smart_agent'
+
+SmartAgent.define :weather_bot do
+  result = call_worker(:weather, params, with_tools: true)
+  if result.call_tools? 
+    weather_result = call_tools(result)
+    return call_worker(:weather_summary, params, weather_result, with_tools: false)
+  else
+    return result
+  end
+end
+
+SmartAgent::Tool.define :get_weather do |location, date|
+  param_define :location, "City or More Specific Address", :str
+  param_define :date, "Specific Date or Today or Tomorrow", :date
+  # Call the Weather API
+end
+
+engine = SmartPrompt::Engine.new("./config/llm_config.yml")
+SmartAgent.engine = engine
+agent = SmartAgent.create(:weather_bot, [:get_weather])
+
+puts agent.please("Get tomorrow's weather forecast in Shanghai")
+```
+
+## Installation
+
+Add to your Gemfile:
+```ruby
+gem 'smart_agent'
+```
+
+Then execute:
+```bash
+bundle install
+```
+
+Or install directly:
+```bash
+gem install smart_agent
+```
+
+## Documentation
+
+Full documentation available at: [docs.smartagent.dev](https://docs.smartagent.dev)
+
+## Contributing
+
+1. Fork the repository
+2. Create feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit changes (`git commit -m 'Add some amazing feature'`)
+4. Push branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE) for details.

data/lib/smart_agent/agent.rb

@@ -0,0 +1,128 @@
+module SmartAgent
+  class Agent
+    attr_accessor :tools, :servers
+
+    def initialize(name, tools: nil, mcp_servers: nil)
+      SmartAgent.logger.info "Create agent's name is #{name}"
+      @name = name
+      @tools = tools
+      @servers = mcp_servers
+      @code = self.class.agents[name]
+    end
+
+    def on_reasoning(&block)
+      @reasoning_event_proc = block
+    end
+
+    def on_content(&block)
+      @content_event_proc = block
+    end
+
+    def on_tool_call(&block)
+      @tool_call_proc = block
+    end
+
+    def on_event
+      if @reasoning_event_proc || @content_event_proc
+        return true
+      else
+        return false
+      end
+    end
+
+    def processor(name)
+      case name
+      when :reasoning
+        return @reasoning_event_proc
+      when :content
+        return @content_event_proc
+      when :tool
+        return @tool_call_proc
+      else
+        return nil
+      end
+    end
+
+    def please(prompt)
+      context = AgentContext.new(self)
+      context.params[:text] = prompt
+      return context.instance_eval(&@code)
+    end
+
+    class << self
+      def agents
+        @agents ||= {}
+      end
+
+      def define(name, &block)
+        agents[name] = block
+      end
+    end
+  end
+
+  class AgentContext
+    def initialize(agent)
+      @agent = agent
+    end
+
+    def call_worker(name, params, result: nil, with_tools: true)
+      if result
+        params[:result] = result
+      end
+      if with_tools
+        if @agent.tools
+          simple_tools = @agent.tools.map { |tool_name| Tool.new(tool_name).to_json }
+        end
+        if @agent.servers
+          mcp_tools = @agent.servers.map { |mcp_name| MCPClient.new(mcp_name).to_json }
+          mcp_tools.each do |tools|
+            tools["tools"].each do |tool|
+              simple_tools << tool
+            end
+          end
+        end
+        params[:tools] = simple_tools
+      end
+      ret = nil
+      if @agent.on_event && with_tools == false
+        SmartAgent.prompt_engine.call_worker_by_stream(name, params) do |chunk, _bytesize|
+          if chunk.dig("choices", 0, "delta", "reasoning_content")
+            @agent.processor(:reasoning).call(chunk)
+          end
+          if chunk.dig("choices", 0, "delta", "content")
+            @agent.processor(:content).call(chunk)
+          end
+        end
+      else
+        result = SmartAgent.prompt_engine.call_worker(name, params)
+        ret = Result.new(result)
+        return ret
+      end
+    end
+
+    def call_tools(result)
+      @agent.processor(:tool).call({ :status => :start })
+      SmartAgent.logger.info("call tools: " + result.to_s)
+      results = []
+      result.call_tools.each do |tool|
+        tool_name = tool["function"]["name"].to_sym
+        params = JSON.parse(tool["function"]["arguments"])
+        if Tool.find_tool(tool_name)
+          @agent.processor(:tool).call({ :content => "ToolName is `#{tool_name}`" })
+          results << Tool.new(tool_name).call(params)
+        end
+        if server_name = MCPClient.find_server_by_tool_name(tool_name)
+          @agent.processor(:tool).call({ :content => "MCP Server is `#{server_name}`, ToolName is `#{tool_name}`" })
+          results << MCPClient.new(server_name).call(tool_name, params)
+        end
+        @agent.processor(:tool).call({ :content => " ... done\n" })
+      end
+      @agent.processor(:tool).call({ :status => :end })
+      return results
+    end
+
+    def params
+      @params ||= {}
+    end
+  end
+end

data/lib/smart_agent/engine.rb

@@ -0,0 +1,78 @@
+module SmartAgent
+  class Engine
+    def initialize(config_file)
+      @config_file = config_file
+      load_config(config_file)
+      SmartAgent.logger.info "Started create the SmartAgent engine."
+    end
+
+    def create_dir(filename)
+      path = File::path(filename).to_s
+      parent_dir = File::dirname(path)
+      Dir.mkdir(parent_dir, 0755) unless File.directory?(parent_dir)
+    end
+
+    def load_config(config_file)
+      begin
+        @config_file = config_file
+        @config = YAML.load_file(config_file)
+        if @config["logger_file"]
+          create_dir(@config["logger_file"])
+          SmartAgent.logger = Logger.new(@config["logger_file"])
+        end
+        if engine_config = @config["engine_config"]
+          SmartAgent.prompt_engine = SmartPrompt::Engine.new(engine_config)
+        else
+          SmartAgent.logger.error "SmartPrompt Config file not found: #{ex.message}"
+          raise ConfigurationError, "SmartPrompt Config file not found: #{ex.message}"
+        end
+        load_tools
+        load_mcp_server
+        load_agents
+        SmartAgent.logger.info "Loading configuration from file: #{config_file}"
+      rescue Psych::SyntaxError => ex
+        SmartAgent.logger.error "YAML syntax error in config file: #{ex.message}"
+        raise ConfigurationError, "Invalid YAML syntax in config file: #{ex.message}"
+      rescue Errno::ENOENT => ex
+        SmartAgent.logger.error "Config file not found: #{ex.message}"
+        raise ConfigurationError, "Config file not found: #{ex.message}"
+      rescue StandardError => ex
+        SmartAgent.logger.error "Error loading configuration: #{ex.message}"
+        raise ConfigurationError, "Error loading configuration: #{ex.message}"
+      ensure
+        SmartAgent.logger.info "Configuration loaded successfully"
+      end
+    end
+
+    def load_tools
+      Dir.glob(File.join(@config["tools_path"], "*.rb")).each do |file|
+        require(file)
+      end
+    end
+
+    def load_mcp_server
+      Dir.glob(File.join(@config["mcp_path"], "*.rb")).each do |file|
+        require(file)
+      end
+    end
+
+    def load_agents
+      Dir.glob(File.join(@config["agent_path"], "*.rb")).each do |file|
+        require(file)
+      end
+    end
+
+    def build_agent(name, tools: nil, mcp_servers: nil)
+      agent = Agent.new(name, tools: tools, mcp_servers: mcp_servers)
+      agents[name] = agent
+    end
+
+    def agents
+      self.class.agents
+    end
+
+    def self.agents
+      @agents ||= {}
+    end
+  end
+end

data/lib/smart_agent/mcp_client.rb

@@ -0,0 +1,74 @@
+module SmartAgent
+  class MCPClient
+    def initialize(name)
+      SmartAgent.logger.info "Create mcp server's name is #{name}"
+      @name = name
+      @code = self.class.servers[name]
+    end
+
+    def to_json
+      @context = MCPContext.new
+      @context.instance_eval(&@code)
+      command_path = @context.command_path
+      client = MCP::Client.new(command_path)
+      client.start
+      mcp_server_json = client.list_tools
+      if mcp_server_json
+        mcp_server_json["tools"].each do |tool|
+          MCPClient.set_server(tool["name"].to_sym, @name)
+        end
+      end
+      convertFormat(mcp_server_json)
+    end
+
+    def call(tool_name, params)
+      @context = MCPContext.new
+      @context.instance_eval(&@code)
+      command_path = @context.command_path
+      client = MCP::Client.new(command_path)
+      client.start
+      client.call_method(
+        {
+          "name": tool_name.to_s,
+          "arguments": params,
+        }
+      )
+    end
+
+    class << self
+      def servers
+        @servers ||= {}
+      end
+
+      def tool_to_server
+        @tool_to_server ||= {}
+      end
+
+      def define(name, &block)
+        servers[name] = block
+      end
+
+      def set_server(tool_name, server_name)
+        tool_to_server[tool_name] = server_name
+      end
+
+      def find_server_by_tool_name(tool_name)
+        tool_to_server[tool_name]
+      end
+    end
+  end
+
+  class MCPContext
+    def type(mcp_type)
+      @mcp_type = mcp_type
+    end
+
+    def command_path
+      @command_path
+    end
+
+    def command(path)
+      @command_path = path
+    end
+  end
+end

data/lib/smart_agent/result.rb

@@ -0,0 +1,24 @@
+module SmartAgent
+  class Result
+    def initialize(response)
+      SmartAgent.logger.info("response is:" + response.to_s)
+      @response = response
+    end
+
+    def call_tools
+      if @response.class == String
+        return nil
+      else
+        @response.dig("choices", 0, "message", "tool_calls")
+      end
+    end
+
+    def content
+      @response.dig("choices", 0, "message", "content")
+    end
+
+    def response
+      @response
+    end
+  end
+end

data/lib/smart_agent/tool.rb

@@ -0,0 +1,67 @@
+module SmartAgent
+  class Tool
+    def initialize(name)
+      SmartAgent.logger.info "Create tool's name is #{name}"
+      @name = name
+      @code = self.class.tools[name]
+    end
+
+    def call(params)
+      @context = ToolContext.new
+      @context.input_params = params
+      @context.instance_eval(&@code)
+    end
+
+    def to_json
+      @context = ToolContext.new
+      @context.instance_eval(&@code)
+      params = @context.params
+
+      properties = params.each_with_object({}) do |(name, details), hash|
+        hash[name] = {
+          type: details[:type],
+          description: details[:description],
+        }
+      end
+
+      return {
+               type: "function",
+               function: {
+                 name: @name,
+                 description: "",
+                 parameters: {
+                   type: "object",
+                   properties: properties,
+                   required: params.keys,
+                 },
+               },
+             }
+    end
+
+    class << self
+      def tools
+        @tools ||= {}
+      end
+
+      def define(name, &block)
+        tools[name] = block
+      end
+
+      def find_tool(name)
+        tools[name]
+      end
+    end
+  end
+
+  class ToolContext
+    attr_accessor :input_params
+
+    def params
+      @params ||= {}
+    end
+
+    def param_define(name, description, type)
+      params[name] = { description: description, type: type }
+    end
+  end
+end

data/lib/smart_agent/version.rb

@@ -0,0 +1,3 @@
+module SmartAgent
+  VERSION = "0.1.1"
+end

data/lib/smart_agent.rb

@@ -0,0 +1,46 @@
+require "../mcp-sdk.rb/lib/mcp"
+
+require File.expand_path("../smart_agent/version", __FILE__)
+require File.expand_path("../smart_agent/engine", __FILE__)
+require File.expand_path("../smart_agent/tool", __FILE__)
+require File.expand_path("../smart_agent/mcp_client", __FILE__)
+require File.expand_path("../smart_agent/result", __FILE__)
+require File.expand_path("../smart_agent/agent", __FILE__)
+
+module SmartAgent
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class APIError < Error; end
+  class CallAgentError < Error; end
+
+  attr_writer :logger
+
+  def self.define(name, &block)
+    Agent.define(name, &block)
+  end
+
+  def self.create(name, tools: nil, mcp_servers: nil)
+    Agent.new(name, tools: tools, mcp_servers: mcp_servers)
+  end
+
+  def self.build_agent(name, tools: nil, mcp_servers: nil)
+    agent = Agent.new(name, tools: tools, mcp_servers: mcp_servers)
+    SmartAgent::Engine.agents[name] = agent
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.prompt_engine
+    @prompt_engine
+  end
+
+  def self.prompt_engine=(engine)
+    @prompt_engine = engine
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: smart_agent
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Your Name
+bindir: bin
+cert_chain: []
+date: 2025-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: smart_prompt
+  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: rspec
+  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: Build AI agents with declarative DSL and Model Context Protocol support
+email:
+- your.email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/smart_agent.rb
+- lib/smart_agent/agent.rb
+- lib/smart_agent/engine.rb
+- lib/smart_agent/mcp_client.rb
+- lib/smart_agent/result.rb
+- lib/smart_agent/tool.rb
+- lib/smart_agent/version.rb
+homepage: https://github.com/yourname/smart_agent
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.4
+specification_version: 4
+summary: Intelligent agent framework with DSL and MCP integration
+test_files: []