Re-arch hello world

autogpt/core/__init__.py

@@ -0,0 +1,11 @@
+from autogpt.core.agent import Agent
+from autogpt.core.budget import BudgetManager
+from autogpt.core.command import Command, CommandRegistry
+from autogpt.core.configuration import Configuration
+from autogpt.core.llm import LanguageModel
+from autogpt.core.logging import Logger
+from autogpt.core.memory import MemoryBackend
+from autogpt.core.messaging import Message, MessageBroker
+from autogpt.core.planning import Planner
+from autogpt.core.plugin import Plugin, PluginManager
+from autogpt.core.workspace import Workspace

autogpt/core/agent/__init__.py

@@ -0,0 +1,2 @@
+"""The Agent is an autonomouos entity guided by a LLM provider."""
+from autogpt.core.agent.base import Agent

autogpt/core/agent/base.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import abc
+import logging
+from importlib import import_module
+from typing import List, Tuple, Type
+
+from autogpt.core.budget import BudgetManager
+from autogpt.core.command import CommandRegistry
+from autogpt.core.configuration import Configuration
+from autogpt.core.llm import LanguageModel
+from autogpt.core.logging import Logger
+from autogpt.core.memory import MemoryBackend
+from autogpt.core.messaging import MessageBroker
+from autogpt.core.planning import Planner
+from autogpt.core.plugin import PluginManager
+from autogpt.core.workspace import Workspace
+
+
+class Agent(abc.ABC):
+    def __init__(
+        self,
+        configuration: Configuration,
+        logger: Logger,
+        budget_manager: BudgetManager,
+        command_registry: CommandRegistry,
+        language_model: LanguageModel,
+        memory_backend: MemoryBackend,
+        message_broker: MessageBroker,
+        planner: Planner,
+        plugin_manager: PluginManager,
+        workspace: Workspace,
+    ):
+        self.configuration = configuration
+        self.logger = logger
+
+        self.budget_manager = budget_manager
+        self.command_registry = command_registry
+        self.language_model = language_model
+        self.memory_backend = memory_backend
+        self.message_broker = message_broker
+        self.planner = planner
+        self.plugin_manager = plugin_manager
+        self.workspace = workspace
+
+
+    @classmethod
+    @abc.abstractmethod
+    def from_workspace(cls, workpace_path: Workspace, message_broker: MessageBroker) -> Agent:
+        pass
+
+
+    @abc.abstractmethod
+    def run(self):
+        pass
+
+
+class AgentFactory:
+
+    configuration_defaults = {
+        # Which subsystems to use. These must be subclasses of the base classes,
+        # but could come from plugins.
+        'system': {
+            'budget_manager': 'autogpt.core.budget.BudgetManager',
+            'command_registry': 'autogpt.core.command.CommandRegistry',
+            'language_model': 'autogpt.core.llm.LanguageModel',
+            'memory_backend': 'autogpt.core.memory.MemoryBackend',
+            'planner': 'autogpt.core.planning.Planner',
+        }
+    }
+
+    def __init__(self, logger: logging.Logger):
+        self._logger = logger
+
+    def compile_configuration(self, user_configuration: dict) -> Tuple[Configuration, List[str]]:
+        """Compile the user's configuration with the defaults."""
+
+        configuration_dict = self.configuration_defaults
+        # Copy so we're not mutating the data structure we're looping over.
+        system_defaults = self.configuration_defaults['system'].copy()
+        # Build up default configuration
+        for system_name in system_defaults:
+            system_class = self.get_system_class(system_name, user_configuration)
+            configuration_dict.update(system_class.configuration_defaults)
+
+        # Apply user overrides
+        configuration_dict.update(user_configuration)
+
+        # TODO: Validate the user configuration and compile errors.
+        agent_configuration = Configuration(configuration_dict)
+        configuration_errors = []
+        return agent_configuration, configuration_errors
+
+    def get_system_class(self, system_name, configuration: dict | Configuration):
+        """Get the system class for the given configuration."""
+        if isinstance(configuration, Configuration):
+            configuration = configuration.to_dict()
+
+        default_system_import_path = self.configuration_defaults['system'][system_name]
+        system_import_path = configuration['system'].get(system_name, default_system_import_path)
+
+        module_path, _, class_name = system_import_path.rpartition(".")
+        module = import_module(module_path)
+        system_class = getattr(module, class_name)
+
+        return system_class
+

autogpt/core/app_sketch/client.py

@@ -0,0 +1,87 @@
+import logging
+
+from autogpt.core.app_sketch.server import bootstrap_agent, launch_agent
+from autogpt.core.messaging.simple import SimpleMessageBroker
+
+
+def configure_application_logging(
+    application_logger: logging.Logger,
+    file_based_configuration: dict,
+    command_line_arguments: dict,
+):
+    application_logger.setLevel(logging.DEBUG)
+
+
+def start_message_broker(application_logger) -> SimpleMessageBroker:
+    # This can take a lot of different forms. E.g. if I'm building an app that connects
+    # to an existing agent on a server, I might just need to connect to a websocket.
+    # If I'm launching a bunch of agents on a cluster, I might need to stand up a
+    # message broker process like redis and launch an Agent factory process.
+    # We're going to do some in-process setup for now by wiring up a simple message
+    # broker and registering a listener for the user_objective message.
+
+    message_broker = SimpleMessageBroker(application_logger)
+
+    # This would happen on the "server" side, but hook here because we're
+    # doing everything in-process.
+    # FIXME: I'm misuing message channels here. Message broker needs to be set up
+    #   so that register_listener can subscribe to a channel and filter messages
+    #   based on their metadata.
+    message_broker.register_listener(
+        "user_objective",
+        bootstrap_agent,
+    )
+    message_broker.register_listener(
+        "launch_agent",
+        launch_agent,
+    )
+
+    message_broker.register_listener(
+        "agent_setup",
+        lambda message: application_logger.info(message.content["message"]),
+    )
+    message_broker.register_listener(
+        "agent_setup_complete",
+        lambda x: None,
+    )
+
+    return message_broker
+
+
+def run_auto_gpt(
+    file_based_configuration: dict,  # Need to figure out what's in here
+    command_line_arguments: dict,    # Need to figure out what's in here
+):
+    # Configure logging before we do anything else.
+    # Application logs need a place to live.
+    application_logger = logging.getLogger("autogpt")
+    configure_application_logging(
+        application_logger,
+        file_based_configuration,
+        command_line_arguments,
+    )
+
+    message_broker = start_message_broker(application_logger)
+
+    # This application either starts an existing agent or builds a new one.
+    if command_line_arguments['agent_name'] is None:
+        # Find out the user's objective for the new agent.
+        user_objective = input(...)
+        # Construct a message to send to the agent.  Real format TBD.
+        user_objective_message = {
+            # This might be like a websocket, (hostname, port) tuple, or something else.
+            "message_broker": message_broker,
+            # These will need structures with some strongly-enforced fields to be
+            # interpreted by the bootstrapping system.
+            # Command line arguments override file-based configuration.
+            "user_configuration": file_based_configuration.update(command_line_arguments),
+            "user_objective": user_objective,
+        }
+        message_broker.send_message("user_objective", user_objective_message)
+
+    launch_agent_message = {
+        "message_broker": message_broker,
+        "agent": command_line_arguments['agent_name'],
+    }
+    message_broker.send_message("launch_agent", launch_agent_message)
+

autogpt/core/app_sketch/server.py

@@ -0,0 +1,112 @@
+import logging
+
+from autogpt.core.agent.base import AgentFactory, Agent
+from autogpt.core.messaging.base import Message
+
+
+def configure_agent_factory_logging(
+    agent_factory_logger: logging.Logger,
+):
+    agent_factory_logger.setLevel(logging.DEBUG)
+
+
+def get_agent_factory():
+    # Configure logging before we do anything else.
+    # Factory logs need a place to live.
+    agent_factory_logger = logging.getLogger("autogpt_agent_factory")
+    configure_agent_factory_logging(
+        agent_factory_logger,
+    )
+    return AgentFactory(agent_factory_logger)
+
+
+def bootstrap_agent(
+    message: Message,
+):
+    """Provision a new agent by getting an objective from the user and setting up agent resources."""
+    # TODO: this could be an already running process we communicate with via the
+    # message broker.  For now, we'll just do it in-process.
+    agent_factory = get_agent_factory()
+
+    message_content = message.content
+    message_broker = message_content["message_broker"]
+    user_configuration = message_content["user_configuration"]
+    user_objective = message_content["user_objective"]
+
+    message_broker.send_message(
+        "agent_setup",
+        {"message": "Startup request received, Setting up agent..."},
+    )
+
+    # Either need to do validation as we're building the configuration, or shortly
+    # after.
+    configuration, configuration_errors = agent_factory.compile_configuration(
+        user_configuration,
+    )
+    if configuration_errors:
+        message_broker.send_message(
+            "agent_setup",
+            {"message": "Configuration errors encountered, aborting agent setup.",
+             "errors": configuration_errors},
+        )
+        return
+
+    message_broker.send_message(
+        "agent_setup",
+        {"message": "Agent configuration compiled. Constructing initial agent plan from user objective.",
+         "configuration": configuration},
+    )
+
+    agent_planner = agent_factory.get_system_class('planner', configuration)
+    # TODO: is this a class method?  Or do we have the planner be partially initialized
+    #  without access to any resources since this precedes Agent creation?
+    objective_prompt = agent_planner.construct_objective_prompt_from_user_input(
+        user_objective,
+    )
+
+    message_broker.send_message(
+        "agent_setup",
+        {"message": "Translated user input into objective prompt.",
+         "user_objective": user_objective,
+         "objective_prompt": objective_prompt},
+    )
+
+    language_model = agent_factory.get_system_class('language_model', configuration)
+    # TODO: is this a class method?  Or do we have the language model be
+    #  partially initialized without access to any resources since this precedes
+    #  Agent creation?
+    model_response = language_model.construct_objective_from_prompt(objective_prompt)
+    # This should be parsed into a standard format already
+    agent_objective = model_response.content
+
+    message_broker.send_message(
+        "agent_setup",
+        {"message": "Translated objective prompt into objective.",
+         "objective_prompt": objective_prompt,
+         "objective": agent_objective},
+    )
+    # ...Update API budget, etc. ...
+
+    # TODO: Set up workspace
+    # TODO: Provision memory backend
+
+    message_broker.send_message(
+        "agent_setup_complete",
+        {"message": "Agent setup complete."}
+    )
+
+
+def _get_workspace_path_from_agent_name(agent_name: str) -> str:
+    # FIXME: Very much a stand-in for later logic. This could be a whole agent registry
+    #  system and probably lives on the client side instead of here
+    return f"~/autogpt_workspace/{agent_name}"
+
+
+def launch_agent(message: Message):
+    message_content = message.content
+    message_broker = message_content["message_broker"]
+    agent_name = message_content["agent_name"]
+    workspace_path = _get_workspace_path_from_agent_name(agent_name)
+
+    agent = Agent.from_workspace(workspace_path, message_broker)
+    agent.run()

autogpt/core/budget/__init__.py

@@ -0,0 +1,2 @@
+"""The budget subsystem manages resource limits for the Agent."""
+from autogpt.core.budget.base import BudgetManager

autogpt/core/budget/base.py

@@ -0,0 +1,5 @@
+import abc
+
+
+class BudgetManager(abc.ABC):
+    pass

autogpt/core/command/__init__.py

@@ -0,0 +1,2 @@
+"""The command system provides a way to extend the functionality of the AI agent."""
+from autogpt.core.command.base import Command, CommandRegistry

autogpt/core/command/base.py

@@ -0,0 +1,9 @@
+import abc
+
+
+class Command(abc.ABC):
+    pass
+
+
+class CommandRegistry(abc.ABC):
+    pass

autogpt/core/configuration/__init__.py

@@ -0,0 +1,2 @@
+"""The configuration encapsulates settings for all Agent subsystems."""
+from autogpt.core.configuration.base import Configuration