deepagents 0.1.0

data/lib/deepagents/deepagentsrb/graph.rb

@@ -0,0 +1,213 @@
+require_relative 'tools'
+require_relative 'state'
+require_relative 'sub_agent'
+require_relative 'models'
+require 'securerandom'
+
+module DeepAgentsRb
+  module Graph
+    # Base prompt for all deep agents
+    BASE_PROMPT = <<~PROMPT
+      You have access to a number of standard tools
+
+      ## `write_todos`
+
+      You have access to the `write_todos` tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+      These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+
+      It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
+      ## `task`
+
+      - When doing web search, prefer to use the `task` tool in order to reduce context usage.
+    PROMPT
+    
+    # Get the default model
+    def self.get_default_model
+      Models.get_default_model
+    end
+    
+    # Create a deep agent
+    def self.create_deep_agent(tools, instructions, model: nil, subagents: nil, state_schema: nil)
+      # Combine instructions with base prompt
+      prompt = instructions + BASE_PROMPT
+      
+      # Get built-in tools
+      built_in_tools = Tools.built_in_tools
+      
+      # Set default model if not provided
+      model ||= get_default_model
+      
+      # Set default state schema
+      state_schema ||= DeepAgentState
+      
+      # Convert subagents to proper format if provided
+      subagents = (subagents || []).map do |agent|
+        if agent.is_a?(Hash)
+          SubAgent.from_h(agent)
+        else
+          agent
+        end
+      end
+      
+      # Create task tool for delegating to sub-agents
+      task_tool = SubAgentSystem.create_task_tool(
+        tools + built_in_tools,
+        instructions,
+        subagents,
+        model,
+        state_schema
+      )
+      
+      # Combine all tools
+      all_tools = built_in_tools + tools + [task_tool]
+      
+      # Create and return the deep agent
+      DeepAgent.new(model, prompt, all_tools, state_schema)
+    end
+  end
+  
+  # Deep Agent class
+  class DeepAgent
+    attr_reader :model, :prompt, :tools, :state_class
+    
+    def initialize(model, prompt, tools, state_class)
+      @model = model
+      @prompt = prompt
+      @tools = tools
+      @state_class = state_class
+    end
+    
+    def invoke(input)
+      # Create initial state
+      state = @state_class.new
+      
+      # Add messages to state if provided
+      if input[:messages]
+        state.messages = input[:messages]
+      end
+      
+      # Add files to state if provided
+      if input[:files]
+        state.files = input[:files]
+      end
+      
+      # Start the agent loop
+      run_agent_loop(state)
+    end
+    
+    def run_agent_loop(state)
+      # Maximum number of iterations to prevent infinite loops
+      max_iterations = 10
+      iterations = 0
+      
+      while iterations < max_iterations
+        iterations += 1
+        
+        # Get the current messages
+        messages = state.messages
+        
+        # Generate a response from the model
+        response = @model.generate(@prompt, messages)
+        
+        # Parse the response for tool calls
+        tool_calls = parse_tool_calls(response)
+        
+        if tool_calls.empty?
+          # No tool calls, just add the response as an assistant message
+          state.update(messages: [{ role: "assistant", content: response }])
+          break
+        else
+          # Add the response with tool calls as an assistant message
+          state.update(messages: [{ role: "assistant", content: response }])
+          
+          # Execute each tool call
+          tool_results = []
+          tool_calls.each do |tool_call|
+            result = execute_tool_call(tool_call, state)
+            tool_results << result
+            
+            # Update state with tool result if it's a Command
+            if result.is_a?(Tools::Command)
+              state.update(result.update)
+            else
+              # Add tool result as a tool message
+              state.update(messages: [{ 
+                role: "tool", 
+                content: result.to_s,
+                tool_call_id: tool_call[:id]
+              }])
+            end
+          end
+          
+          # Check if we should continue the loop
+          if should_continue?(response, tool_results)
+            next
+          else
+            break
+          end
+        end
+      end
+      
+      state
+    end
+    
+    private
+    
+    def parse_tool_calls(response)
+      # This is a simple implementation that looks for tool calls in the format:
+      # ```tool_call
+      # {"name": "tool_name", "arguments": {"arg1": "value1", ...}}
+      # ```
+      
+      tool_calls = []
+      tool_call_pattern = /```tool_call\s+({[\s\S]*?})\s+```/m
+      
+      response.scan(tool_call_pattern).each do |match|
+        begin
+          tool_data = JSON.parse(match[0])
+          tool_calls << {
+            id: SecureRandom.uuid,
+            name: tool_data["name"],
+            arguments: tool_data["arguments"]
+          }
+        rescue JSON::ParserError => e
+          # Skip invalid JSON
+        end
+      end
+      
+      tool_calls
+    end
+    
+    def execute_tool_call(tool_call, state)
+      tool_name = tool_call[:name]
+      arguments = tool_call[:arguments]
+      tool_call_id = tool_call[:id]
+      
+      # Find the tool
+      tool = @tools.find { |t| t.name == tool_name }
+      
+      if tool.nil?
+        return "Error: Tool '#{tool_name}' not found"
+      end
+      
+      # Execute the tool
+      begin
+        # Add state and tool_call_id to arguments
+        kwargs = arguments.transform_keys(&:to_sym)
+        kwargs[:state] = state
+        kwargs[:tool_call_id] = tool_call_id
+        
+        # Call the tool
+        tool.call(**kwargs)
+      rescue ArgumentError => e
+        "Error executing tool '#{tool_name}': #{e.message}"
+      end
+    end
+    
+    def should_continue?(response, tool_results)
+      # Check if the response or any tool result indicates we should continue
+      # For now, we'll just continue if any tool was executed successfully
+      !tool_results.empty?
+    end
+  end
+end

data/lib/deepagents/deepagentsrb/models.rb

@@ -0,0 +1,167 @@
+module DeepAgentsRb
+  module Models
+    # Base model interface that all model adapters should implement
+    class BaseModel
+      def generate(prompt, messages)
+        raise NotImplementedError, "Subclasses must implement the generate method"
+      end
+      
+      def stream_generate(prompt, messages, &block)
+        # Default implementation just calls generate and yields the result
+        # Subclasses can override for true streaming
+        result = generate(prompt, messages)
+        yield result if block_given?
+        result
+      end
+    end
+    
+    # Anthropic Claude model adapter
+    class Claude < BaseModel
+      def initialize(api_key: nil, model: "claude-3-sonnet-20240229", client: nil)
+        require 'anthropic'
+        @api_key = api_key || ENV['ANTHROPIC_API_KEY']
+        @model = model
+        @client = client || Anthropic::Client.new(api_key: @api_key)
+      end
+      
+      def generate(prompt, messages)
+        response = @client.messages(
+          model: @model,
+          max_tokens: 4096,
+          messages: messages,
+          system: prompt
+        )
+        response.content[0].text
+      end
+      
+      def stream_generate(prompt, messages, &block)
+        response = @client.messages(
+          model: @model,
+          max_tokens: 4096,
+          messages: messages,
+          system: prompt,
+          stream: true
+        )
+        
+        full_text = ""
+        response.each do |chunk|
+          if chunk.type == "content_block_delta" && chunk.delta.type == "text"
+            full_text += chunk.delta.text
+            yield chunk.delta.text if block_given?
+          end
+        end
+        
+        full_text
+      end
+    end
+    
+    # OpenAI model adapter
+    class OpenAI < BaseModel
+      def initialize(api_key: nil, model: "gpt-4o", client: nil)
+        require 'openai'
+        @api_key = api_key || ENV['OPENAI_API_KEY']
+        @model = model
+        @client = client || ::OpenAI::Client.new(access_token: @api_key)
+      end
+      
+      def generate(prompt, messages)
+        # Convert messages to OpenAI format if needed
+        openai_messages = messages.map do |msg|
+          msg = msg.transform_keys(&:to_sym) if msg.is_a?(Hash)
+          msg
+        end
+        
+        # Add system message with prompt
+        openai_messages.unshift({ role: "system", content: prompt }) unless prompt.nil? || prompt.empty?
+        
+        response = @client.chat(
+          parameters: {
+            model: @model,
+            messages: openai_messages
+          }
+        )
+        
+        response.dig("choices", 0, "message", "content")
+      end
+      
+      def stream_generate(prompt, messages, &block)
+        # Convert messages to OpenAI format if needed
+        openai_messages = messages.map do |msg|
+          msg = msg.transform_keys(&:to_sym) if msg.is_a?(Hash)
+          msg
+        end
+        
+        # Add system message with prompt
+        openai_messages.unshift({ role: "system", content: prompt }) unless prompt.nil? || prompt.empty?
+        
+        full_text = ""
+        @client.chat(
+          parameters: {
+            model: @model,
+            messages: openai_messages,
+            stream: true
+          }
+        ) do |chunk|
+          content = chunk.dig("choices", 0, "delta", "content")
+          if content
+            full_text += content
+            yield content if block_given?
+          end
+        end
+        
+        full_text
+      end
+    end
+    
+    # Mock model for testing
+    class MockModel < BaseModel
+      def initialize(responses = {})
+        @responses = responses
+        @default_response = "I'll help you with that task."
+      end
+      
+      def generate(prompt, messages)
+        # Try to match the last user message to a predefined response
+        last_user_message = messages.reverse.find { |m| m[:role] == "user" || m["role"] == "user" }
+        
+        if last_user_message
+          content = last_user_message[:content] || last_user_message["content"]
+          
+          # Check if we have a matching response
+          @responses.each do |key, response|
+            return response if content.include?(key)
+          end
+        end
+        
+        # Return default response if no match found
+        @default_response
+      end
+    end
+    
+    # Get the default model (used when no model is specified)
+    def self.get_default_model
+      # Try to use Claude if the API key is available
+      if ENV['ANTHROPIC_API_KEY']
+        begin
+          require 'anthropic'
+          return Claude.new
+        rescue LoadError
+          # Anthropic gem not available
+        end
+      end
+      
+      # Try to use OpenAI if the API key is available
+      if ENV['OPENAI_API_KEY']
+        begin
+          require 'openai'
+          return OpenAI.new
+        rescue LoadError
+          # OpenAI gem not available
+        end
+      end
+      
+      # Fall back to mock model
+      MockModel.new
+    end
+  end
+end

data/lib/deepagents/deepagentsrb/state.rb

@@ -0,0 +1,139 @@
+require_relative 'errors'
+
+module DeepAgentsRb
+  # Todo class for managing todos
+  class Todo
+    attr_accessor :content, :status
+    
+    def initialize(content, status = "pending")
+      raise ArgumentError, "Todo content cannot be nil or empty" if content.nil? || content.empty?
+      @content = content
+      @status = validate_status(status)
+    end
+    
+    def to_h
+      {
+        content: @content,
+        status: @status
+      }
+    end
+    
+    def self.from_h(hash)
+      content = hash[:content] || hash["content"]
+      status = hash[:status] || hash["status"] || "pending"
+      
+      raise ArgumentError, "Todo hash must contain content" if content.nil?
+      new(content, status)
+    end
+    
+    private
+    
+    def validate_status(status)
+      valid_statuses = ["pending", "in_progress", "completed"]
+      status = status.to_s.downcase
+      
+      unless valid_statuses.include?(status)
+        raise ArgumentError, "Invalid todo status: #{status}. Must be one of: #{valid_statuses.join(', ')}"
+      end
+      
+      status
+    end
+  end
+  
+  # Deep agent state class
+  class DeepAgentState
+    attr_reader :todos, :files, :messages
+    
+    def initialize
+      @todos = []
+      @files = {}
+      @messages = []
+    end
+    
+    def todos=(value)
+      @todos = validate_todos(value)
+    end
+    
+    def files=(value)
+      raise ArgumentError, "Files must be a hash" unless value.is_a?(Hash)
+      @files = value
+    end
+    
+    def messages=(value)
+      raise ArgumentError, "Messages must be an array" unless value.is_a?(Array)
+      @messages = value
+    end
+    
+    def get(key, default = nil)
+      case key.to_s
+      when "todos"
+        @todos
+      when "files"
+        @files
+      when "messages"
+        @messages
+      else
+        default
+      end
+    end
+    
+    def update(todos: nil, files: nil, messages: nil)
+      begin
+        if todos
+          @todos = validate_todos(todos)
+        end
+        
+        if files
+          raise ArgumentError, "Files must be a hash" unless files.is_a?(Hash)
+          @files.merge!(files)
+        end
+        
+        if messages
+          raise ArgumentError, "Messages must be an array" unless messages.is_a?(Array)
+          @messages += messages
+        end
+      rescue => e
+        raise StateError, "Failed to update state: #{e.message}"
+      end
+    end
+    
+    def [](key)
+      get(key)
+    end
+    
+    def []=(key, value)
+      case key.to_s
+      when "todos"
+        self.todos = value
+      when "files"
+        self.files = value
+      when "messages"
+        self.messages = value
+      else
+        raise ArgumentError, "Unknown state key: #{key}"
+      end
+    end
+    
+    def to_h
+      {
+        todos: @todos.map(&:to_h),
+        files: @files,
+        messages: @messages
+      }
+    end
+    
+    private
+    
+    def validate_todos(todos)
+      raise ArgumentError, "Todos must be an array" unless todos.is_a?(Array)
+      
+      todos.map do |todo|
+        if todo.is_a?(Todo)
+          todo
+        else
+          Todo.from_h(todo)
+        end
+      end
+    end
+  end
+end

data/lib/deepagents/deepagentsrb/sub_agent.rb

@@ -0,0 +1,125 @@
+module DeepAgentsRb
+  # SubAgent class to define sub-agents
+  class SubAgent
+    attr_reader :name, :description, :prompt, :tools
+    
+    def initialize(name:, description:, prompt:, tools: nil)
+      @name = name
+      @description = description
+      @prompt = prompt
+      @tools = tools
+    end
+    
+    def to_h
+      hash = {
+        name: @name,
+        description: @description,
+        prompt: @prompt
+      }
+      hash[:tools] = @tools if @tools
+      hash
+    end
+    
+    def self.from_h(hash)
+      new(
+        name: hash[:name],
+        description: hash[:description],
+        prompt: hash[:prompt],
+        tools: hash[:tools]
+      )
+    end
+  end
+  
+  module SubAgentSystem
+    # Task description templates
+    TASK_DESCRIPTION_PREFIX = "Use this tool to delegate a task to a sub-agent. Available sub-agents:\n- general-purpose: A general purpose agent with the same capabilities as the main agent\n{other_agents}"
+    TASK_DESCRIPTION_SUFFIX = "\n\nThe sub-agent will have access to the same tools as you do, and will be able to use them to complete the task."
+    
+    # Create a task tool for delegating to sub-agents
+    def self.create_task_tool(tools, instructions, subagents, model, state_class)
+      # Create agents hash with general-purpose agent
+      agents = {
+        "general-purpose" => ReactAgent.new(model, instructions, tools, state_class)
+      }
+      
+      # Create tools by name hash
+      tools_by_name = {}
+      tools.each do |tool|
+        tools_by_name[tool.name] = tool
+      end
+      
+      # Create sub-agents
+      subagents.each do |agent|
+        if agent.tools
+          agent_tools = agent.tools.map { |t| tools_by_name[t] }
+        else
+          agent_tools = tools
+        end
+        
+        agents[agent.name] = ReactAgent.new(model, agent.prompt, agent_tools, state_class)
+      end
+      
+      # Create other agents string for task description
+      other_agents_string = subagents.map do |agent|
+        "- #{agent.name}: #{agent.description}"
+      end
+      
+      # Create task tool
+      Tools::Tool.new(
+        "task",
+        TASK_DESCRIPTION_PREFIX.gsub("{other_agents}", other_agents_string.join("\n")) + TASK_DESCRIPTION_SUFFIX
+      ) do |description, subagent_type, state, tool_call_id:|
+        if !agents.key?(subagent_type)
+          return "Error: invoked agent of type #{subagent_type}, the only allowed types are #{agents.keys.map { |k| "`#{k}`" }}"
+        end
+        
+        sub_agent = agents[subagent_type]
+        sub_state = state.dup
+        sub_state.messages = [{ role: "user", content: description }]
+        
+        result = sub_agent.invoke(sub_state)
+        
+        Tools::Command.new(
+          update: {
+            files: result.get("files", {}),
+            messages: [
+              Tools::ToolMessage.new(
+                result.messages.last[:content],
+                tool_call_id: tool_call_id
+              )
+            ]
+          }
+        )
+      end
+    end
+  end
+  
+  # Simple React Agent implementation
+  class ReactAgent
+    attr_reader :model, :prompt, :tools, :state_class
+    
+    def initialize(model, prompt, tools, state_class)
+      @model = model
+      @prompt = prompt
+      @tools = tools
+      @state_class = state_class
+    end
+    
+    def invoke(state)
+      # In a real implementation, this would use the LLM to:
+      # 1. Process the input state
+      # 2. Decide which tool to use
+      # 3. Call the tool
+      # 4. Process the tool result
+      # 5. Repeat until done
+      # 6. Return the final response
+      
+      # For now, we'll just return a simple response
+      state.update(
+        messages: [{ role: "assistant", content: "I've completed the task: #{state.messages.last[:content]}" }]
+      )
+      
+      state
+    end
+  end
+end