digital-employee-core 0.0.1__tar.gz

digital_employee_core-0.0.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: digital-employee-core
+Version: 0.0.1
+Summary: 
+Author: Digital Employee Team
+Requires-Python: >=3.11,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aip-agents-binary (>=0.4.8,<0.5.0)
+Requires-Dist: apscheduler (>=3.11.0,<4.0.0)
+Requires-Dist: authlib (>=1.6.1,<2.0.0)
+Requires-Dist: email-validator (>=2.3.0,<3.0.0)
+Requires-Dist: fastapi (>=0.117.1,<0.118.0)
+Requires-Dist: glaip-sdk (>=0.6.2)
+Requires-Dist: gllm-plugin-binary (>=0.0.7,<0.0.8)
+Requires-Dist: google-api-python-client (>=2.0.0,<3.0.0)
+Requires-Dist: opentelemetry-instrumentation-httpx
+Requires-Dist: opentelemetry-instrumentation-requests
+Requires-Dist: pre-commit (>=4.2.0,<5.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: python-multipart (>=0.0.20,<0.0.21)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: requests (>=2.32.0,<3.0.0)
+Requires-Dist: ruff (>=0.14.0,<0.15.0)
+Requires-Dist: uvicorn (>=0.34.0,<0.35.0)
+Description-Content-Type: text/markdown
+
+# Digital Employee Core
+
+A Python library for building and managing AI-powered digital employees with support for tools, MCPs (Model Context Protocol), and flexible configuration management.
+
+## Setup
+
+### 1. Install Dependencies
+
+```bash
+poetry install
+```
+
+### 2. Configure Environment
+
+Copy the example environment file and add your credentials:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with your configuration:
+
+```bash
+# Required
+AIP_API_URL=https://your-ai-platform-url.com
+AIP_API_KEY=your-api-key
+
+# Optional: Google MCP Configuration
+GOOGLE_CALENDAR_MCP_URL=https://api.example.com/calendar/mcp
+GOOGLE_DOCS_MCP_URL=https://api.example.com/docs/mcp
+GOOGLE_MCP_X_API_KEY=your-google-mcp-key
+```
+
+## Run Examples
+
+### Basic Usage
+
+```bash
+poetry run python examples/basic_usage.py
+```
+
+### Configuration Usage
+
+```bash
+poetry run python examples/configuration_usage.py
+```
+
+### Subclass Example
+
+```bash
+poetry run python examples/subclass_example.py
+```
+
+## Run Tests
+
+```bash
+# Run all tests
+poetry run pytest
+
+# Run with verbose output
+poetry run pytest -v
+
+# Run with coverage
+poetry run coverage run -m pytest
+poetry run coverage report
+
+# Run with coverage HTML report
+poetry run coverage run -m pytest
+poetry run coverage html
+# Open htmlcov/index.html in browser
+
+# Run specific test file
+poetry run pytest tests/digital_employee/test_digital_employee.py
+```
+

digital_employee_core-0.0.1/README.md

@@ -0,0 +1,74 @@
+# Digital Employee Core
+
+A Python library for building and managing AI-powered digital employees with support for tools, MCPs (Model Context Protocol), and flexible configuration management.
+
+## Setup
+
+### 1. Install Dependencies
+
+```bash
+poetry install
+```
+
+### 2. Configure Environment
+
+Copy the example environment file and add your credentials:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with your configuration:
+
+```bash
+# Required
+AIP_API_URL=https://your-ai-platform-url.com
+AIP_API_KEY=your-api-key
+
+# Optional: Google MCP Configuration
+GOOGLE_CALENDAR_MCP_URL=https://api.example.com/calendar/mcp
+GOOGLE_DOCS_MCP_URL=https://api.example.com/docs/mcp
+GOOGLE_MCP_X_API_KEY=your-google-mcp-key
+```
+
+## Run Examples
+
+### Basic Usage
+
+```bash
+poetry run python examples/basic_usage.py
+```
+
+### Configuration Usage
+
+```bash
+poetry run python examples/configuration_usage.py
+```
+
+### Subclass Example
+
+```bash
+poetry run python examples/subclass_example.py
+```
+
+## Run Tests
+
+```bash
+# Run all tests
+poetry run pytest
+
+# Run with verbose output
+poetry run pytest -v
+
+# Run with coverage
+poetry run coverage run -m pytest
+poetry run coverage report
+
+# Run with coverage HTML report
+poetry run coverage run -m pytest
+poetry run coverage html
+# Open htmlcov/index.html in browser
+
+# Run specific test file
+poetry run pytest tests/digital_employee/test_digital_employee.py
+```

digital_employee_core-0.0.1/digital_employee_core/__init__.py

@@ -0,0 +1,26 @@
+"""Digital employee Core package.
+
+This package provides the core functionality for building and managing
+digital employees with support for tools, MCPs, and configurations.
+"""
+
+from digital_employee_core.config_templates import ConfigTemplateLoader
+from digital_employee_core.configuration import DigitalEmployeeConfiguration
+from digital_employee_core.digital_employee import DigitalEmployee
+from digital_employee_core.identity import (
+    DigitalEmployeeIdentity,
+    DigitalEmployeeJob,
+    DigitalEmployeeSupervisor,
+)
+
+__all__ = [
+    # Core classes
+    "ConfigTemplateLoader",
+    "DigitalEmployee",
+    # Identity classes
+    "DigitalEmployeeIdentity",
+    "DigitalEmployeeJob",
+    "DigitalEmployeeSupervisor",
+    # Configuration classes
+    "DigitalEmployeeConfiguration",
+]

digital_employee_core-0.0.1/digital_employee_core/agents/__init__.py

@@ -0,0 +1 @@
+"""Agents package for digital employee core."""

digital_employee_core-0.0.1/digital_employee_core/config_templates/__init__.py

@@ -0,0 +1,8 @@
+"""Configuration template utilities.
+
+This module provides utilities for loading and processing configuration templates.
+"""
+
+from digital_employee_core.config_templates.loader import ConfigTemplateLoader
+
+__all__ = ["ConfigTemplateLoader"]

digital_employee_core-0.0.1/digital_employee_core/config_templates/loader.py

@@ -0,0 +1,187 @@
+"""Configuration template loader and processor.
+
+This module provides utilities for loading and processing configuration templates
+from YAML files, replacing placeholders with values from DigitalEmployeeConfiguration objects.
+
+Authors:
+    Immanuel Rhesa (immanuel.rhesa@gdplabs.id)
+
+References:
+    NONE
+"""
+
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from digital_employee_core.configuration.configuration import DigitalEmployeeConfiguration
+
+# Configuration template filenames
+MCP_CONFIGS_TEMPLATE = "mcp_configs.yaml"
+TOOL_CONFIGS_TEMPLATE = "tool_configs.yaml"
+
+
+class ConfigTemplateLoader:
+    """Loads and processes configuration templates from YAML files.
+
+    This class handles loading YAML configuration templates and replacing
+    placeholders with actual values from DigitalEmployeeConfiguration objects.
+
+    Attributes:
+        template_dir (Path): Path to the directory containing template files.
+    """
+
+    def __init__(self, template_dir: str | Path | None = None):
+        """Initialize the ConfigTemplateLoader.
+
+        Args:
+            template_dir (str | Path | None, optional): Path to template directory. Defaults to config_templates
+                in the package directory.
+        """
+        if template_dir is None:
+            # Default to config_templates directory in the package
+            package_dir = Path(__file__).parent.parent
+            template_dir = package_dir / "config_templates"
+
+        self.template_dir = Path(template_dir)
+
+    def load_template(self, filename: str) -> dict[str, Any]:
+        """Load a YAML template file.
+
+        Args:
+            filename (str): Name of the template file (e.g., 'mcp_configs.yaml').
+
+        Returns:
+            dict[str, Any]: Dictionary containing the template configuration.
+
+        Raises:
+            FileNotFoundError: If the template file does not exist.
+        """
+        template_path = self.template_dir / filename
+        return self.load_template_from_path(template_path)
+
+    def load_template_from_path(self, filepath: str | Path) -> dict[str, Any]:
+        """Load a YAML template file from an absolute path.
+
+        Args:
+            filepath (str | Path): Absolute path to the template file.
+
+        Returns:
+            dict[str, Any]: Dictionary containing the template configuration.
+
+        Raises:
+            FileNotFoundError: If the template file does not exist.
+        """
+        template_path = Path(filepath)
+        if not template_path.exists():
+            raise FileNotFoundError(f"Template file not found: {template_path}")
+
+        with open(template_path) as f:
+            return yaml.safe_load(f) or {}
+
+    @staticmethod
+    def merge_configs(
+        base_config: dict[str, dict[str, Any]],
+        additional_config: dict[str, dict[str, Any]],
+    ) -> dict[str, dict[str, Any]]:
+        """Merge two configuration dictionaries.
+
+        The additional_config will override values in base_config for matching keys.
+        New keys in additional_config will be added to the result.
+        Performs recursive deep merge for nested dictionaries.
+
+        Args:
+            base_config (dict[str, dict[str, Any]]): Base configuration dictionary.
+            additional_config (dict[str, dict[str, Any]]): Additional configuration to merge.
+
+        Returns:
+            dict[str, dict[str, Any]]: Merged configuration dictionary.
+        """
+
+        def _deep_merge(base: dict[str, Any], additional: dict[str, Any]) -> dict[str, Any]:
+            """Recursively merge two dictionaries."""
+            result = base.copy()
+            for key, value in additional.items():
+                if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                    # Recursively merge nested dictionaries
+                    result[key] = _deep_merge(result[key], value)
+                else:
+                    # Override or add new key
+                    result[key] = value
+            return result
+
+        return _deep_merge(base_config, additional_config)
+
+    def _replace_placeholders(
+        self,
+        template: dict[str, Any],
+        configurations: list[DigitalEmployeeConfiguration],
+    ) -> dict[str, Any]:
+        """Replace placeholders in template with configuration values.
+
+        Placeholders are in format <PLACEHOLDER_KEY> and are replaced with
+        values from DigitalEmployeeConfiguration objects matching the key.
+
+        Args:
+            template (dict[str, Any]): Template dictionary with placeholders.
+            configurations (list[DigitalEmployeeConfiguration]): List of DigitalEmployeeConfiguration objects.
+
+        Returns:
+            dict[str, Any]: Dictionary with placeholders replaced by actual values.
+        """
+        # Create a mapping of keys to values from configurations
+        config_map: dict[str, str] = {}
+        for config in configurations:
+            config_map[config.key] = config.value
+
+        def replace_value(value: Any) -> Any:
+            """Recursively replace placeholders in values."""
+            if isinstance(value, str):
+                # Find all placeholders in format <KEY>
+                placeholders = re.findall(r"<([^>]+)>", value)
+                result = value
+                for placeholder in placeholders:
+                    if placeholder in config_map:
+                        # Replace the placeholder with the actual value
+                        result = result.replace(f"<{placeholder}>", config_map[placeholder])
+                return result
+            elif isinstance(value, dict):
+                return {k: replace_value(v) for k, v in value.items()}
+            elif isinstance(value, list):
+                return [replace_value(item) for item in value]
+            else:
+                return value
+
+        return replace_value(template)
+
+    def load_mcp_configs(
+        self,
+        configurations: list[DigitalEmployeeConfiguration],
+    ) -> dict[str, dict[str, Any]]:
+        """Load MCP configuration template and replace placeholders.
+
+        Args:
+            configurations (list[DigitalEmployeeConfiguration]): List of DigitalEmployeeConfiguration objects.
+
+        Returns:
+            dict[str, dict[str, Any]]: Dictionary mapping MCP names to their configurations.
+        """
+        template = self.load_template(MCP_CONFIGS_TEMPLATE)
+        return self._replace_placeholders(template, configurations)
+
+    def load_tool_configs(
+        self,
+        configurations: list[DigitalEmployeeConfiguration],
+    ) -> dict[str, dict[str, Any]]:
+        """Load tool configuration template and replace placeholders.
+
+        Args:
+            configurations (list[DigitalEmployeeConfiguration]): List of DigitalEmployeeConfiguration objects.
+
+        Returns:
+            dict[str, dict[str, Any]]: Dictionary mapping tool names to their configurations.
+        """
+        template = self.load_template(TOOL_CONFIGS_TEMPLATE)
+        return self._replace_placeholders(template, configurations)

digital_employee_core-0.0.1/digital_employee_core/config_templates/mcp_configs.yaml

@@ -0,0 +1,54 @@
+# MCP Configuration Templates
+#
+# This file contains configuration templates for MCPs (Model Context Protocol servers).
+# Placeholders in angle brackets (e.g., <PLACEHOLDER_KEY>) will be replaced with values
+# from DigitalEmployeeConfiguration objects at runtime using the placeholder key.
+#
+# Format:
+#   mcp-name:
+#     config:
+#       key: value or <PLACEHOLDER_KEY>
+#     authentication:
+#       type: "api-key" | "oauth" | "bearer"
+#       key: "header-name"
+#       value: <PLACEHOLDER_KEY>
+
+digital_employee_google_calendar_mcp:
+  config:
+    url: <GOOGLE_CALENDAR_MCP_URL>
+  authentication:
+    type: api-key
+    key: X-API-Key
+    value: <GOOGLE_MCP_X_API_KEY>
+
+digital_employee_google_docs_mcp:
+  config:
+    url: <GOOGLE_DOCS_MCP_URL>
+  authentication:
+    type: api-key
+    key: X-API-Key
+    value: <GOOGLE_MCP_X_API_KEY>
+
+digital_employee_google_drive_mcp:
+  config:
+    url: <GOOGLE_DRIVE_MCP_URL>
+  authentication:
+    type: api-key
+    key: X-API-Key
+    value: <GOOGLE_MCP_X_API_KEY>
+
+digital_employee_google_mail_mcp:
+  config:
+    url: <GOOGLE_MAIL_MCP_URL>
+  authentication:
+    type: api-key
+    key: X-API-Key
+    value: <GOOGLE_MCP_X_API_KEY>
+
+digital_employee_google_sheets_mcp:
+  config:
+    url: <GOOGLE_SHEETS_MCP_URL>
+  authentication:
+    type: api-key
+    key: X-API-Key
+    value: <GOOGLE_MCP_X_API_KEY>

digital_employee_core-0.0.1/digital_employee_core/config_templates/tool_configs.yaml

@@ -0,0 +1,9 @@
+# Tool Configuration Templates
+#
+# This file contains configuration templates for tools.
+# Placeholders in angle brackets (e.g., <PLACEHOLDER_KEY>) will be replaced with values
+# from DigitalEmployeeConfiguration objects at runtime using the placeholder key.
+#
+# Format:
+#   tool_name:
+#     key: value or <PLACEHOLDER_KEY>

digital_employee_core-0.0.1/digital_employee_core/configuration/__init__.py

@@ -0,0 +1,7 @@
+"""Configuration management module for digital employee."""
+
+from .configuration import DigitalEmployeeConfiguration
+
+__all__ = [
+    "DigitalEmployeeConfiguration",
+]

digital_employee_core-0.0.1/digital_employee_core/configuration/configuration.py

@@ -0,0 +1,27 @@
+"""Configuration and credentials management for digital employee.
+
+This module provides classes for managing configuration credentials.
+
+Authors:
+    Immanuel Rhesa (immanuel.rhesa@gdplabs.id)
+
+References:
+    NONE
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class DigitalEmployeeConfiguration:
+    """Represents a single configuration for digital employee.
+
+    This class combines both configuration and credential information.
+
+    Attributes:
+        key (str): The configuration key identifier (e.g., "GOOGLE_MCP_X_API_KEY", "SPREADSHEET_ID").
+        value (str): The configuration value or credential.
+    """
+
+    key: str
+    value: str

digital_employee_core-0.0.1/digital_employee_core/connectors/__init__.py

@@ -0,0 +1,4 @@
+"""Connectors module for digital employee Core.
+
+This module contains various connectors and integration components.
+"""

digital_employee_core-0.0.1/digital_employee_core/connectors/mcps/__init__.py

@@ -0,0 +1,22 @@
+"""MCPs package for Digital Employee Core.
+
+This package provides pre-configured MCP instances for various services.
+"""
+
+from digital_employee_core.connectors.mcps.google_mcps import (
+    ALL_GOOGLE_MCPS,
+    google_calendar_mcp,
+    google_docs_mcp,
+    google_drive_mcp,
+    google_mail_mcp,
+    google_sheets_mcp,
+)
+
+__all__ = [
+    "google_calendar_mcp",
+    "google_docs_mcp",
+    "google_drive_mcp",
+    "google_mail_mcp",
+    "google_sheets_mcp",
+    "ALL_GOOGLE_MCPS",
+]

digital_employee_core-0.0.1/digital_employee_core/connectors/mcps/google_mcps.py

@@ -0,0 +1,62 @@
+"""Google MCPs for Digital Employee Core.
+
+This module provides pre-configured MCP instances for Google services
+that can be easily imported and used in Digital Employee implementations.
+
+Authors:
+    Immanuel Rhesa (immanuel.rhesa@gdplabs.id)
+
+References:
+    NONE
+"""
+
+from glaip_sdk import MCP
+
+# Google Calendar MCP
+google_calendar_mcp = MCP(
+    name="digital_employee_google_calendar_mcp",
+    description="MCP for Google Calendar Operation for DE",
+    transport="http",
+    config={"url": "https://default.com/google_calendar/mcp"},
+)
+
+# Google Docs MCP
+google_docs_mcp = MCP(
+    name="digital_employee_google_docs_mcp",
+    description="MCP for Google Docs Operation for DE",
+    transport="http",
+    config={"url": "https://default.com/google_docs/mcp"},
+)
+
+# Google Drive MCP
+google_drive_mcp = MCP(
+    name="digital_employee_google_drive_mcp",
+    description="MCP for Google Drive Operation for DE",
+    transport="http",
+    config={"url": "https://default.com/google_drive/mcp"},
+)
+
+# Google Mail MCP
+google_mail_mcp = MCP(
+    name="digital_employee_google_mail_mcp",
+    description="MCP for Google Mail Operation for DE",
+    transport="http",
+    config={"url": "https://default.com/google_mail/mcp"},
+)
+
+# Google Sheets MCP
+google_sheets_mcp = MCP(
+    name="digital_employee_google_sheets_mcp",
+    description="MCP for Google Sheets Operation for DE",
+    transport="http",
+    config={"url": "https://default.com/google_sheets/mcp"},
+)
+
+# Convenience list of all Google MCPs
+ALL_GOOGLE_MCPS = [
+    google_calendar_mcp,
+    google_docs_mcp,
+    google_drive_mcp,
+    google_mail_mcp,
+    google_sheets_mcp,
+]

digital_employee_core-0.0.1/digital_employee_core/connectors/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools package for digital employee core."""

digital_employee_core-0.0.1/digital_employee_core/digital_employee/__init__.py

@@ -0,0 +1,8 @@
+"""Digital Employee module.
+
+This module provides the main DigitalEmployee orchestrator class.
+"""
+
+from digital_employee_core.digital_employee.digital_employee import DigitalEmployee
+
+__all__ = ["DigitalEmployee"]

digital_employee_core-0.0.1/digital_employee_core/digital_employee/digital_employee.py

@@ -0,0 +1,367 @@
+"""Core digital employee orchestrator.
+
+This module provides the base DigitalEmployee class that manages agents,
+tools, and MCPs. It implements the ConfigBuilder interface to
+provide configuration building capabilities.
+
+Authors:
+    Immanuel Rhesa (immanuel.rhesa@gdplabs.id)
+
+References:
+    NONE
+"""
+
+from typing import Any
+
+from glaip_sdk import MCP, Agent, Tool
+
+from digital_employee_core.config_templates.loader import ConfigTemplateLoader
+from digital_employee_core.configuration.configuration import (
+    DigitalEmployeeConfiguration,
+)
+from digital_employee_core.identity.identity import DigitalEmployeeIdentity
+
+
+class DigitalEmployee:
+    """Core digital employee orchestrator.
+
+    This class manages the lifecycle of a digital employee, including
+    initialization, deployment, and execution of agents with tools and MCPs.
+    Provides methods for building tool and MCP configurations from YAML templates.
+
+    Attributes:
+        identity (DigitalEmployeeIdentity): The digital employee's identity.
+        tools (list[Tool]): List of tools the digital employee can use.
+        sub_agents (list[Agent]): List of sub-agents (for future use).
+        mcps (list[MCP]): List of MCPs the digital employee can use.
+        configurations (list[DigitalEmployeeConfiguration]): List of configuration objects for tools and MCPs.
+        agent (Agent | None): The main agent instance.
+        config_loader (ConfigTemplateLoader): The configuration template loader instance.
+    """
+
+    def __init__(
+        self,
+        identity: DigitalEmployeeIdentity,
+        tools: list[Tool] | None = None,
+        sub_agents: list[Agent] | None = None,
+        mcps: list[MCP] | None = None,
+        configurations: list[DigitalEmployeeConfiguration] | None = None,
+    ):
+        """Initialize the digital employee.
+
+        Args:
+            identity (DigitalEmployeeIdentity): The digital employee's identity.
+            tools (list[Tool] | None, optional): List of tools the digital employee can use. Defaults to None.
+            sub_agents (list[Agent] | None, optional): List of sub-agents (for future use). Defaults to None.
+            mcps (list[MCP] | None, optional): List of MCPs the digital employee can use. Defaults to None.
+            configurations (list[DigitalEmployeeConfiguration] | None, optional): List of configuration objects
+                for tools and MCPs. Defaults to None.
+        """
+        self.identity = identity
+        self.tools = tools or []
+        self.sub_agents = sub_agents or []
+        self.mcps = mcps or []
+        self.configurations = configurations or []
+        self.agent: Agent | None = None
+        self.config_loader = ConfigTemplateLoader()
+
+    def add_tools(self, tools: list[Tool]) -> None:
+        """Add tools to the digital employee.
+
+        Args:
+            tools (list[Tool]): List of tools to add.
+        """
+        self.tools.extend(tools)
+
+    def add_mcps(self, mcps: list[MCP]) -> None:
+        """Add MCPs to the digital employee.
+
+        Args:
+            mcps (list[MCP]): List of MCPs to add.
+        """
+        self.mcps.extend(mcps)
+
+    def add_sub_agents(self, sub_agents: list[Agent]) -> None:
+        """Add sub-agents to the digital employee.
+
+        Args:
+            sub_agents (list[Agent]): List of sub-agents to add.
+        """
+        self.sub_agents.extend(sub_agents)
+
+    def build_instruction(self) -> str:
+        """Build the instruction/prompt for the agent.
+
+        This method can be overridden by subclasses to provide custom
+        instructions based on the digital employee's identity and job.
+        Always includes the digital employee's name, email, and language preferences
+        in the prompt to ensure identity awareness.
+
+        Returns:
+            str: The instruction string for the agent.
+        """
+        # Build identity information with language
+        language_names = [lang.value for lang in self.identity.languages]
+
+        if len(language_names) > 1:
+            language_list = ", ".join(language_names[:-1]) + f" and {language_names[-1]}"
+            language_instruction = (
+                f"You must respond only in the following languages: {language_list}. "
+                f"Choose the most appropriate language based on the user's input or context."
+            )
+        else:
+            language_instruction = f"You must respond only in {language_names[0]} language."
+
+        identity_prefix = (
+            f"You are {self.identity.name} ({self.identity.email}), {self.identity.job.title}. "
+            f"{language_instruction}"
+        )
+
+        return f"{identity_prefix}\n\n{self.identity.job.instruction}"
+
+    def deploy(self) -> None:
+        """Deploy the digital employee.
+
+        This method initializes the agent with tools and MCPs,
+        applies configurations to MCPs and tools, and deploys it to the AI platform.
+        """
+        if self.configurations:
+            tool_configs = self.build_tool_config(self.configurations)
+            mcp_configs = self.build_mcp_config(self.configurations)
+            configured_mcps = self._apply_mcp_configs(self.mcps, mcp_configs)
+            configured_tools = self._apply_tool_configs(self.tools, tool_configs)
+        else:
+            configured_mcps = self.mcps
+            configured_tools = self.tools
+
+        self.agent = Agent(
+            name=self.identity.name,
+            description=self.identity.job.description,
+            instruction=self.build_instruction(),
+            tools=configured_tools,
+            agents=self.sub_agents,
+            mcps=configured_mcps,
+        )
+
+        self.agent.deploy()
+
+    def run(
+        self,
+        message: str,
+        configurations: list[DigitalEmployeeConfiguration] | None = None,
+    ) -> str:
+        """Run the digital employee with a message.
+
+        Args:
+            message (str): The message/prompt to send to the digital employee.
+            configurations (list[DigitalEmployeeConfiguration] | None, optional): List of configuration objects.
+                Defaults to None.
+
+        Returns:
+            str: The agent's response as a string.
+
+        Raises:
+            RuntimeError: If the agent has not been deployed.
+        """
+        if self.agent is None:
+            raise RuntimeError("Agent has not been deployed. Call deploy() before run().")
+
+        configurations = configurations or []
+        runtime_config = self._build_runtime_configs(configurations)
+
+        return self.agent.run(message=message, runtime_config=runtime_config)
+
+    def build_tool_config(self, configurations: list[DigitalEmployeeConfiguration]) -> dict[str, dict[str, Any]]:
+        """Build tool configuration based on identity and configurations.
+
+        This method loads tool configuration templates from YAML and replaces
+        placeholders with values from DigitalEmployeeConfiguration objects. Subclasses can
+        override this to provide custom logic and merge with parent configs.
+
+        Example for subclasses:
+            def build_tool_config(self, configurations):
+                # Get base configs from parent
+                base_configs = super().build_tool_config(configurations)
+
+                # Load additional configs for this subclass
+                additional = self.config_loader.load_tool_configs(configurations)
+
+                # Merge them
+                return self.config_loader.merge_configs(base_configs, additional)
+
+        Args:
+            configurations: List of configuration objects.
+
+        Returns:
+            dict[str, dict[str, Any]]: Dictionary mapping tool names to their configuration dictionaries.
+        """
+        return self.config_loader.load_tool_configs(configurations)
+
+    def build_mcp_config(self, configurations: list[DigitalEmployeeConfiguration]) -> dict[str, dict[str, Any]]:
+        """Build MCP configuration based on identity and configurations.
+
+        This method loads MCP configuration templates from YAML and replaces
+        placeholders with values from DigitalEmployeeConfiguration objects. Subclasses can
+        override this to provide custom logic and merge with parent configs.
+
+        Example for subclasses:
+            def build_mcp_config(self, configurations):
+                # Get base configs from parent
+                base_configs = super().build_mcp_config(configurations)
+
+                # Load additional configs for this subclass
+                additional = self.config_loader.load_mcp_configs(configurations)
+
+                # Merge them
+                return self.config_loader.merge_configs(base_configs, additional)
+
+        Args:
+            configurations (list[DigitalEmployeeConfiguration]): List of configuration objects.
+
+        Returns:
+            dict[str, dict[str, Any]]: Dictionary mapping MCP names to their configuration dictionaries.
+        """
+        return self.config_loader.load_mcp_configs(configurations)
+
+    def _apply_mcp_configs(
+        self,
+        mcps: list[MCP],
+        mcp_configs: dict[str, dict[str, Any]],
+    ) -> list[MCP]:
+        """Apply configurations to MCPs.
+
+        This method updates the config and authentication attributes of MCPs
+        based on the provided configuration dictionary. Only updates MCPs
+        that have matching configurations.
+
+        Args:
+            mcps (list[MCP]): List of MCP instances.
+            mcp_configs (dict[str, dict[str, Any]]): Dictionary mapping MCP names to their configurations.
+
+        Returns:
+            list[MCP]: List of MCPs with configurations applied.
+        """
+        return [self._apply_single_mcp_config(mcp, mcp_configs) for mcp in mcps]
+
+    def _apply_single_mcp_config(self, mcp: MCP, mcp_configs: dict[str, dict[str, Any]]) -> MCP:
+        """Apply configuration to a single MCP.
+
+        Args:
+            mcp (MCP): MCP instance to configure.
+            mcp_configs (dict[str, dict[str, Any]]): Dictionary mapping MCP names to their configurations.
+
+        Returns:
+            MCP: MCP with configuration applied.
+        """
+        if not (mcp.name and mcp.name in mcp_configs):
+            return mcp
+
+        config_data = mcp_configs[mcp.name]
+
+        if config_data.get("config"):
+            if mcp.config is None:
+                mcp.config = {}
+            mcp.config.update(config_data["config"])
+
+        if config_data.get("authentication"):
+            if mcp.authentication is None:
+                mcp.authentication = {}
+            mcp.authentication.update(config_data["authentication"])
+
+        return mcp
+
+    def _apply_tool_configs(
+        self,
+        tools: list[Tool],
+        tool_configs: dict[str, dict[str, Any]],
+    ) -> list[Tool]:
+        """Apply configurations to tools.
+
+        This method updates tool configurations based on the provided
+        configuration dictionary. Only updates tools that have matching
+        configurations and a config attribute.
+
+        Args:
+            tools (list[Tool]): List of tool names (strings) or Tool objects.
+            tool_configs (dict[str, dict[str, Any]]): Dictionary mapping tool names to their configurations.
+
+        Returns:
+            list[Tool]: List of tools with configurations applied.
+        """
+        configured_tools = []
+        for tool in tools:
+            if hasattr(tool, "name") and hasattr(tool, "config"):
+                if tool.name and tool.name in tool_configs:
+                    config_data = tool_configs[tool.name]
+                    if tool.config is None:
+                        tool.config = {}
+                    tool.config.update(config_data)
+
+            configured_tools.append(tool)
+
+        return configured_tools
+
+    def _filter_tool_configs(
+        self,
+        all_tool_configs: dict[str, dict[str, Any]],
+    ) -> dict[str, dict[str, Any]]:
+        """Filter tool configs to only include tools used by the agent.
+
+        Args:
+            all_tool_configs (dict[str, dict[str, Any]]): All available tool configurations.
+
+        Returns:
+            dict[str, dict[str, Any]]: Filtered tool configurations for tools used by the agent.
+        """
+        return {
+            name: config
+            for name, config in all_tool_configs.items()
+            if any(
+                (hasattr(tool, "name") and tool.name == name) or (isinstance(tool, str) and tool == name)
+                for tool in self.agent.tools
+            )
+        }
+
+    def _filter_mcp_configs(
+        self,
+        all_mcp_configs: dict[str, dict[str, Any]],
+    ) -> dict[str, dict[str, Any]]:
+        """Filter MCP configs to only include MCPs used by the agent.
+
+        Args:
+            all_mcp_configs (dict[str, dict[str, Any]]): All available MCP configurations.
+
+        Returns:
+            dict[str, dict[str, Any]]: Filtered MCP configurations for MCPs used by the agent.
+        """
+        return {
+            name: config
+            for name, config in all_mcp_configs.items()
+            if any(
+                (hasattr(mcp, "name") and mcp.name == name) or (isinstance(mcp, str) and mcp == name)
+                for mcp in self.agent.mcps
+            )
+        }
+
+    def _build_runtime_configs(
+        self,
+        configurations: list[DigitalEmployeeConfiguration],
+    ) -> dict[str, dict[str, dict[str, Any]]]:
+        """Build runtime configurations for tools and MCPs.
+
+        This method builds all configurations and filters them to only include
+        tools and MCPs that are actually used by the agent.
+
+        Args:
+            configurations (list[DigitalEmployeeConfiguration]): List of configuration objects.
+
+        Returns:
+            dict[str, dict[str, dict[str, Any]]]: Dictionary with 'tool_configs' and 'mcp_configs' keys.
+        """
+        all_tool_configs = self.build_tool_config(configurations)
+        all_mcp_configs = self.build_mcp_config(configurations)
+
+        return {
+            "tool_configs": self._filter_tool_configs(all_tool_configs),
+            "mcp_configs": self._filter_mcp_configs(all_mcp_configs),
+        }

digital_employee_core-0.0.1/digital_employee_core/identity/__init__.py

@@ -0,0 +1,16 @@
+"""Identity module for digital employee.
+
+This module provides identity classes for digital employees.
+"""
+
+from digital_employee_core.identity.identity import (
+    DigitalEmployeeIdentity,
+    DigitalEmployeeJob,
+    DigitalEmployeeSupervisor,
+)
+
+__all__ = [
+    "DigitalEmployeeIdentity",
+    "DigitalEmployeeJob",
+    "DigitalEmployeeSupervisor",
+]

digital_employee_core-0.0.1/digital_employee_core/identity/identity.py

@@ -0,0 +1,83 @@
+"""Digital employee identity classes.
+
+This module provides identity classes for digital employees with support for
+different levels of identity (base, HR, and specific implementations).
+
+Authors:
+    Immanuel Rhesa (immanuel.rhesa@gdplabs.id)
+
+References:
+    NONE
+"""
+
+from enum import StrEnum
+from typing import Annotated
+
+from pydantic import BaseModel, EmailStr, Field, StringConstraints
+
+
+class LangId(StrEnum):
+    """The language id.
+
+    Attributes:
+        EN: Id for English language.
+        ID: Id for Indonesian language.
+    """
+
+    EN = "en"
+    ID = "id"
+
+
+class DigitalEmployeeJob(BaseModel):
+    """Digital employee Job definition.
+
+    Encapsulates job-specific information for a digital employee,
+    including title, description, and instructions.
+
+    Attributes:
+        title (str): The job title or role name (e.g., "HR Assistant", "Payroll Specialist").
+        description (str): Detailed description of the job and responsibilities.
+        instruction (str): Specific instructions or guidelines for performing the job.
+    """
+
+    title: str
+    description: str
+    instruction: str
+
+
+class DigitalEmployeeSupervisor(BaseModel):
+    """Digital employee Supervisor information.
+
+    Represents the supervisor or manager overseeing the digital employee.
+
+    Attributes:
+        name (str): The supervisor's full name.
+        email (EmailStr): The supervisor's email address. Must be a valid email format.
+    """
+
+    name: str
+    email: EmailStr
+
+
+class DigitalEmployeeIdentity(BaseModel):
+    """Base digital employee Identity.
+
+    This is the base identity class that provides comprehensive information
+    for a digital employee, including personal details, job role, and supervisor.
+
+    Attributes:
+        name (Annotated[str, StringConstraints(max_length=100)]): The name of the digital employee.
+            Maximum length is 100 characters.
+        email (EmailStr): The digital employee's email address. Must be a valid email format.
+        job (DigitalEmployeeJob): The job information (title, description, instruction).
+        supervisor (DigitalEmployeeSupervisor | None, optional): The supervisor information (name and email).
+            Defaults to None.
+        languages (list[LangId]): The list of supported languages for the digital employee.
+            Defaults to [LangId.EN].
+    """
+
+    name: Annotated[str, StringConstraints(max_length=100)]
+    email: EmailStr
+    job: DigitalEmployeeJob
+    supervisor: DigitalEmployeeSupervisor | None = None
+    languages: list[LangId] = Field(default_factory=lambda: [LangId.EN])

digital_employee_core-0.0.1/pyproject.toml

@@ -0,0 +1,64 @@
+[tool.poetry]
+name = "digital-employee-core"
+version = "0.0.1"
+description = ""
+authors = ["Digital Employee Team"]
+readme = "README.md"
+
+
+[tool.poetry.dependencies]
+python = ">=3.11,<3.13"
+
+fastapi = ">=0.117.1,<0.118.0"
+uvicorn = ">=0.34.0,<0.35.0"
+
+authlib = "^1.6.1"
+google-api-python-client = "^2.0.0"
+python-multipart = "^0.0.20"
+opentelemetry-instrumentation-requests = "*"
+opentelemetry-instrumentation-httpx = "*"
+apscheduler = "^3.11.0"
+python-dotenv = "^1.0.0"
+requests = "^2.32.0"
+pre-commit = "^4.2.0"
+glaip-sdk = ">=0.6.2"
+ruff = "^0.14.0"
+
+aip-agents-binary = "^0.4.8"
+gllm-plugin-binary = "^0.0.7"
+pyyaml = "^6.0.3"
+email-validator = "^2.3.0"
+
+[tool.poetry.group.dev.dependencies]
+coverage = "^7.11.0"
+pytest = "^8.4.2"
+pytest-xdist = "^3.8.0"
+black = "^25.1.0"
+flake8 = "^7.3.0"
+faker = "^37.12.0"
+pytest-asyncio = "^1.2.0"
+
+[[tool.poetry.source]]
+name = "gen-ai-internal"
+url = "https://asia-southeast2-python.pkg.dev/gdp-labs/gen-ai-internal/simple/"
+priority = "supplemental"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+norecursedirs = ["docker/*", "pgdata"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+ignore = ["B008", "C901", "E266"]
+select = ["B", "B9", "C", "D", "E", "F", "I", "PL", "W"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D", "PLR", "ARG"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"