deepagents 0.1.0

data/lib/deepagents/deepagentsrb/tools.rb

@@ -0,0 +1,205 @@
+module DeepAgentsRb
+  module Tools
+    # Tool descriptions
+    WRITE_TODOS_DESCRIPTION = "Use this tool to manage and track tasks. It helps you plan and break down complex tasks."
+    EDIT_DESCRIPTION = "Edit a file by replacing specific content."
+    TOOL_DESCRIPTION = "Read a file from the virtual file system."
+    
+    # Tool class to define tools
+    class Tool
+      attr_reader :name, :description, :function
+      
+      def initialize(name, description, &block)
+        @name = name
+        @description = description
+        @function = block
+      end
+      
+      def call(*args, **kwargs)
+        begin
+          @function.call(*args, **kwargs)
+        rescue ArgumentError => e
+          raise ToolError.new(@name, "Invalid arguments: #{e.message}")
+        rescue => e
+          raise ToolError.new(@name, e.message)
+        end
+      end
+    end
+    
+    # Command class to represent tool results
+    class Command
+      attr_reader :update
+      
+      def initialize(update)
+        raise ArgumentError, "Update must be a hash" unless update.is_a?(Hash)
+        @update = update
+      end
+    end
+    
+    # Tool message class
+    class ToolMessage
+      attr_reader :content, :tool_call_id
+      
+      def initialize(content, tool_call_id:)
+        @content = content
+        @tool_call_id = tool_call_id
+      end
+      
+      def to_h
+        {
+          role: "tool",
+          content: @content,
+          tool_call_id: @tool_call_id
+        }
+      end
+    end
+    
+    # Define the write_todos tool
+    def self.write_todos
+      Tool.new("write_todos", WRITE_TODOS_DESCRIPTION) do |todos, tool_call_id:|
+        Command.new(
+          update: {
+            todos: todos,
+            messages: [
+              ToolMessage.new("Updated todo list to #{todos}", tool_call_id: tool_call_id)
+            ]
+          }
+        )
+      end
+    end
+    
+    # Define the ls tool
+    def self.ls
+      Tool.new("ls", "List all files") do |state|
+        state.get("files", {}).keys
+      end
+    end
+    
+    # Define the read_file tool
+    def self.read_file
+      Tool.new("read_file", TOOL_DESCRIPTION) do |file_path, state, offset: 0, limit: 2000|
+        mock_filesystem = state.get("files", {})
+        
+        if !mock_filesystem.key?(file_path)
+          raise FileNotFoundError.new(file_path)
+        end
+        
+        # Get file content
+        content = mock_filesystem[file_path]
+        
+        # Handle empty file
+        if content.nil? || content.strip.empty?
+          return "System reminder: File exists but has empty contents"
+        end
+        
+        # Split content into lines
+        lines = content.split("\n")
+        
+        # Apply line offset and limit
+        start_idx = offset
+        end_idx = [start_idx + limit, lines.length].min
+        
+        # Handle case where offset is beyond file length
+        if start_idx >= lines.length
+          return "Error: Line offset #{offset} exceeds file length (#{lines.length} lines)"
+        end
+        
+        # Format output with line numbers (cat -n format)
+        result_lines = []
+        (start_idx...end_idx).each do |i|
+          line_content = lines[i]
+          
+          # Truncate lines longer than 2000 characters
+          if line_content.length > 2000
+            line_content = line_content[0...2000]
+          end
+          
+          # Line numbers start at 1, so add 1 to the index
+          line_number = i + 1
+          result_lines << "#{line_number.to_s.rjust(6)}\t#{line_content}"
+        end
+        
+        result_lines.join("\n")
+      end
+    end
+    
+    # Define the write_file tool
+    def self.write_file
+      Tool.new("write_file", "Write to a file") do |file_path, content, state, tool_call_id:|
+        files = state.get("files", {})
+        files[file_path] = content
+        
+        Command.new(
+          update: {
+            files: files,
+            messages: [
+              ToolMessage.new("Updated file #{file_path}", tool_call_id: tool_call_id)
+            ]
+          }
+        )
+      end
+    end
+    
+    # Define the edit_file tool
+    def self.edit_file
+      Tool.new("edit_file", EDIT_DESCRIPTION) do |file_path, old_string, new_string, state, tool_call_id:, replace_all: false|
+        mock_filesystem = state.get("files", {})
+        
+        # Check if file exists in mock filesystem
+        if !mock_filesystem.key?(file_path)
+          raise FileNotFoundError.new(file_path)
+          return "Error: File '#{file_path}' not found"
+        end
+        
+        # Get current file content
+        content = mock_filesystem[file_path]
+        
+        # Check if old_string exists in the file
+        if !content.include?(old_string)
+          return "Error: String not found in file: '#{old_string}'"
+        end
+        
+        # If not replace_all, check for uniqueness
+        if !replace_all
+          occurrences = content.scan(old_string).length
+          if occurrences > 1
+            return "Error: String '#{old_string}' appears #{occurrences} times in file. Use replace_all=true to replace all instances, or provide a more specific string with surrounding context."
+          elsif occurrences == 0
+            return "Error: String not found in file: '#{old_string}'"
+          end
+        end
+        
+        # Perform the replacement
+        if replace_all
+          new_content = content.gsub(old_string, new_string)
+          replacement_count = content.scan(old_string).length
+          result_msg = "Successfully replaced #{replacement_count} instance(s) of the string in '#{file_path}'"
+        else
+          new_content = content.sub(old_string, new_string) # Replace only first occurrence
+          result_msg = "Successfully replaced string in '#{file_path}'"
+        end
+        
+        # Update the mock filesystem
+        mock_filesystem[file_path] = new_content
+        
+        Command.new(
+          update: {
+            files: mock_filesystem,
+            messages: [ToolMessage.new(result_msg, tool_call_id: tool_call_id)]
+          }
+        )
+      end
+    end
+    
+    # Get all built-in tools
+    def self.built_in_tools
+      [
+        write_todos,
+        ls,
+        read_file,
+        write_file,
+        edit_file
+      ]
+    end
+  end
+end

data/lib/deepagents/deepagentsrb/version.rb

@@ -0,0 +1,3 @@
+module DeepAgentsRb
+  VERSION = "0.0.1"
+end

data/lib/deepagents/errors.rb

@@ -0,0 +1,80 @@
+module DeepAgents
+  # Base error class for all DeepAgents errors
+  class Error < StandardError; end
+  
+  # Error raised when there's an issue with the state
+  class StateError < Error; end
+  
+  # Error raised when there's an issue with a tool
+  class ToolError < Error
+    attr_reader :tool_name
+    
+    def initialize(tool_name, message)
+      @tool_name = tool_name
+      super("Error in tool '#{tool_name}': #{message}")
+    end
+  end
+  
+  # Error raised when a tool is not found
+  class ToolNotFoundError < ToolError
+    def initialize(tool_name)
+      super(tool_name, "Tool not found")
+    end
+  end
+  
+  # Error raised when there's an issue with a file operation
+  class FileError < Error; end
+  
+  # Error raised when a file is not found
+  class FileNotFoundError < FileError
+    attr_reader :path
+    
+    def initialize(path)
+      @path = path
+      super("File not found: #{path}")
+    end
+  end
+  
+  # Error raised when there's an issue with a model
+  class ModelError < Error; end
+  
+  # Error raised when there's an issue with API credentials
+  class CredentialsError < ModelError
+    def initialize(model_name)
+      super("Missing API credentials for #{model_name}")
+    end
+  end
+  
+  # Error raised when there's an issue with a sub-agent
+  class SubAgentError < Error; end
+  
+  # Error raised when a sub-agent is not found
+  class SubAgentNotFoundError < SubAgentError
+    attr_reader :agent_name
+    
+    def initialize(agent_name)
+      @agent_name = agent_name
+      super("Sub-agent not found: #{agent_name}")
+    end
+  end
+  
+  # Error raised when there's an issue with parsing a tool call
+  class ToolCallParseError < Error
+    attr_reader :raw_content
+    
+    def initialize(message, raw_content = nil)
+      @raw_content = raw_content
+      super(message)
+    end
+  end
+  
+  # Error raised when there's an issue with the LLM response
+  class LLMResponseError < Error; end
+  
+  # Error raised when the maximum number of iterations is reached
+  class MaxIterationsError < Error
+    def initialize(iterations)
+      super("Maximum number of iterations (#{iterations}) reached")
+    end
+  end
+end

data/lib/deepagents/graph.rb

@@ -0,0 +1,207 @@
+require_relative 'errors'
+require_relative 'state'
+require_relative 'tools'
+require_relative 'sub_agent'
+require 'langgraph_rb'
+
+module DeepAgents
+  # ReactAgent class for implementing the React pattern
+  class ReactAgent
+    attr_reader :tools, :instructions, :model, :state
+
+    def initialize(tools, instructions, model, state_schema = nil)
+      @tools = tools
+      @instructions = instructions
+      @model = model
+      @state = DeepAgentState.new
+      @tool_registry = ToolRegistry.new
+      
+      # Register tools
+      tools.each do |tool|
+        @tool_registry.register(tool)
+      end
+    end
+
+    def run(max_iterations = 10)
+      iterations = 0
+      messages = []
+      
+      while iterations < max_iterations
+        iterations += 1
+        
+        prompt = build_prompt(messages)
+        response = @model.generate(prompt, @tools)
+        
+        if response[:tool_calls] && !response[:tool_calls].empty?
+          tool_call = response[:tool_calls].first
+          tool_name = tool_call[:name]
+          tool_args = tool_call[:arguments]
+          
+          begin
+            tool = @tool_registry.get(tool_name)
+            result = execute_tool(tool, tool_args)
+            
+            messages << { role: "assistant", content: "I'll use the #{tool_name} tool." }
+            messages << { role: "system", content: "Tool result: #{result}" }
+          rescue => e
+            messages << { role: "system", content: "Error: #{e.message}" }
+          end
+        else
+          messages << { role: "assistant", content: response[:content] }
+          break
+        end
+      end
+      
+      if iterations >= max_iterations
+        raise MaxIterationsError.new(max_iterations)
+      end
+      
+      # Return the final response
+      messages.last[:content]
+    end
+
+    private
+
+    def build_prompt(messages)
+      prompt = "You are a deep agent with the following instructions:\n\n"
+      prompt += "#{@instructions}\n\n"
+      
+      if @tools && !@tools.empty?
+        prompt += "You have access to the following tools:\n\n"
+        
+        @tools.each do |tool|
+          prompt += "#{tool.name}: #{tool.description}\n"
+          prompt += "Parameters: #{tool.parameters.join(', ')}\n\n"
+        end
+      end
+      
+      if @state && !@state.to_h.empty?
+        prompt += "Current state:\n\n"
+        prompt += "Todos:\n"
+        
+        @state.todos.each_with_index do |todo, index|
+          prompt += "#{index + 1}. [#{todo.status}] #{todo.content}\n"
+        end
+        
+        prompt += "\n"
+        
+        if !@state.files.empty?
+          prompt += "Files:\n"
+          @state.files.each do |path, content|
+            prompt += "- #{path}\n"
+          end
+          prompt += "\n"
+        end
+      end
+      
+      if messages && !messages.empty?
+        prompt += "Previous messages:\n\n"
+        
+        messages.each do |message|
+          prompt += "#{message[:role]}: #{message[:content]}\n\n"
+        end
+      end
+      
+      prompt
+    end
+
+    def execute_tool(tool, args)
+      begin
+        if args.is_a?(Hash)
+          tool.call(**args)
+        else
+          tool.call(args)
+        end
+      rescue => e
+        "Error executing tool: #{e.message}"
+      end
+    end
+  end
+
+  # Graph module for creating deep agents
+  module Graph
+    def self.create_deep_agent(tools, instructions, model: nil, subagents: nil, state_schema: nil)
+      # Create a default model if none is provided
+      if model.nil?
+        begin
+          model = Models::Claude.new
+        rescue => e
+          begin
+            model = Models::OpenAI.new
+          rescue => e2
+            # Fall back to mock model if no API keys are available
+            model = Models::MockModel.new
+          end
+        end
+      end
+      
+      # Add standard tools
+      file_system = FileSystem.new
+      state = state_schema ? state_schema.new : DeepAgentState.new
+      
+      # Create standard tools
+      standard_tools = StandardTools.file_system_tools(file_system) + 
+                      StandardTools.todo_tools(state) + [StandardTools.planning_tool]
+      
+      # Combine with user-provided tools
+      all_tools = tools + standard_tools
+      
+      # Create LangGraph tools
+      langgraph_tools = all_tools.map do |tool|
+        LangGraphRb::Tool.new(
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+          function: ->(args) { tool.call(**args) }
+        )
+      end
+      
+      # Create sub-agent tools if provided
+      if subagents && !subagents.empty?
+        subagent_registry = SubAgentRegistry.new
+        
+        subagents.each do |subagent|
+          subagent_registry.register(subagent)
+          
+          # Create a tool for each subagent
+          subagent_tool = LangGraphRb::Tool.new(
+            name: "task_#{subagent.name}",
+            description: "Use the #{subagent.name} subagent for tasks related to: #{subagent.description}",
+            parameters: { task: "The task to perform" },
+            function: ->(args) { subagent.invoke(args[:task]) }
+          )
+          
+          langgraph_tools << subagent_tool
+        end
+      end
+      
+      # Create the LangGraph agent
+      agent = LangGraphRb::Agent.new(
+        model: model.to_langchain_model,
+        tools: langgraph_tools,
+        system_prompt: instructions,
+        state: state
+      )
+      
+      # Create a wrapper that maintains compatibility with our ReactAgent interface
+      ReactAgentWrapper.new(agent, all_tools, instructions, model, state)
+    end
+    
+    # Wrapper class to maintain compatibility with ReactAgent interface
+    class ReactAgentWrapper
+      attr_reader :tools, :instructions, :model, :state
+      
+      def initialize(langgraph_agent, tools, instructions, model, state)
+        @langgraph_agent = langgraph_agent
+        @tools = tools
+        @instructions = instructions
+        @model = model
+        @state = state
+      end
+      
+      def run(max_iterations = 10)
+        @langgraph_agent.run(max_iterations: max_iterations)
+      end
+    end
+  end
+end

data/lib/deepagents/models.rb

@@ -0,0 +1,217 @@
+require_relative 'errors'
+
+module DeepAgents
+  module Models
+    # Base model class for LLM models
+    class BaseModel
+      attr_reader :model
+
+      def initialize(model:)
+        @model = model
+      end
+
+      def generate(prompt, tools = nil)
+        raise NotImplementedError, "Subclasses must implement the generate method"
+      end
+      
+      def to_langchain_model
+        raise NotImplementedError, "Subclasses must implement the to_langchain_model method"
+      end
+    end
+
+    # Claude model adapter
+    class Claude < BaseModel
+      def initialize(api_key: nil, model: "claude-3-sonnet-20240229")
+        super(model: model)
+        @api_key = api_key || ENV["ANTHROPIC_API_KEY"]
+        
+        begin
+          require 'anthropic'
+        rescue LoadError
+          raise LoadError, "The 'anthropic' gem is required for Claude models"
+        end
+        
+        if @api_key.nil? || @api_key.empty?
+          raise CredentialsError.new("Claude")
+        end
+        
+        @client = Anthropic::Client.new(api_key: @api_key)
+      end
+
+      def generate(prompt, tools = nil)
+        begin
+          messages = [{ role: "user", content: prompt }]
+          
+          params = {
+            model: @model,
+            messages: messages,
+            max_tokens: 4096,
+            temperature: 0.7
+          }
+          
+          if tools && !tools.empty?
+            tool_definitions = tools.map do |tool|
+              {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                  type: "object",
+                  properties: Hash[tool.parameters.map { |param| [param, { type: "string" }] }],
+                  required: tool.parameters
+                }
+              }
+            end
+            
+            params[:tools] = tool_definitions
+          end
+          
+          response = @client.messages.create(**params)
+          
+          if tools && !tools.empty? && response.content.first.type == "tool_use"
+            tool_call = response.content.first.tool_use
+            return {
+              content: nil,
+              tool_calls: [{
+                name: tool_call.name,
+                arguments: tool_call.parameters
+              }]
+            }
+          else
+            return {
+              content: response.content.first.text,
+              tool_calls: []
+            }
+          end
+        rescue => e
+          raise ModelError, "Claude API error: #{e.message}"
+        end
+      end
+      
+      def to_langchain_model
+        # Create and return a langchainrb Claude model
+        require 'langchain'
+        Langchain::LLM::Anthropic.new(
+          api_key: @api_key,
+          model_name: @model
+        )
+      end
+    end
+
+    # OpenAI model adapter
+    class OpenAI < BaseModel
+      def initialize(api_key: nil, model: "gpt-4o")
+        super(model: model)
+        @api_key = api_key || ENV["OPENAI_API_KEY"]
+        
+        begin
+          require 'openai'
+        rescue LoadError
+          raise LoadError, "The 'openai' gem is required for OpenAI models"
+        end
+        
+        if @api_key.nil? || @api_key.empty?
+          raise CredentialsError.new("OpenAI")
+        end
+        
+        @client = ::OpenAI::Client.new(access_token: @api_key)
+      end
+
+      def generate(prompt, tools = nil)
+        begin
+          messages = [{ role: "user", content: prompt }]
+          
+          params = {
+            model: @model,
+            messages: messages,
+            temperature: 0.7,
+            max_tokens: 4096
+          }
+          
+          if tools && !tools.empty?
+            tool_definitions = tools.map do |tool|
+              {
+                type: "function",
+                function: {
+                  name: tool.name,
+                  description: tool.description,
+                  parameters: {
+                    type: "object",
+                    properties: Hash[tool.parameters.map { |param| [param, { type: "string" }] }],
+                    required: tool.parameters
+                  }
+                }
+              }
+            end
+            
+            params[:tools] = tool_definitions
+          end
+          
+          response = @client.chat(parameters: params)
+          
+          if tools && !tools.empty? && response.dig("choices", 0, "message", "tool_calls")
+            tool_call = response.dig("choices", 0, "message", "tool_calls").first
+            return {
+              content: nil,
+              tool_calls: [{
+                name: tool_call["function"]["name"],
+                arguments: JSON.parse(tool_call["function"]["arguments"])
+              }]
+            }
+          else
+            return {
+              content: response.dig("choices", 0, "message", "content"),
+              tool_calls: []
+            }
+          end
+        rescue => e
+          raise ModelError, "OpenAI API error: #{e.message}"
+        end
+      end
+      
+      def to_langchain_model
+        # Create and return a langchainrb OpenAI model
+        require 'langchain'
+        Langchain::LLM::OpenAI.new(
+          api_key: @api_key,
+          model_name: @model
+        )
+      end
+    end
+
+    # Mock model for testing
+    class MockModel < BaseModel
+      def initialize(model: "mock-model")
+        super(model: model)
+      end
+
+      def generate(prompt, tools = nil)
+        if tools && !tools.empty? && prompt.include?("use tool")
+          tool = tools.first
+          return {
+            content: nil,
+            tool_calls: [{
+              name: tool.name,
+              arguments: Hash[tool.parameters.map { |param| [param, "test_value"] }]
+            }]
+          }
+        else
+          return {
+            content: "This is a mock response for: #{prompt}",
+            tool_calls: []
+          }
+        end
+      end
+      
+      def to_langchain_model
+        # Create and return a langchainrb mock model
+        require 'langchain'
+        Langchain::LLM::Base.new.tap do |model|
+          # Override the complete method to return mock responses
+          def model.complete(prompt:, **_kwargs)
+            "This is a mock response from langchain for: #{prompt}"
+          end
+        end
+      end
+    end
+  end
+end