agentr 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

agentr/cli.py

@@ -1,75 +1,76 @@
-import typer
-from pathlib import Path
-import sys
-
-app = typer.Typer()
-
-@app.command()
-def version():
-    """Show the version of the CLI"""
-    print("agentr version 0.1.0")
-
-@app.command()
-def generate(schema_path: Path = typer.Option(..., "--schema", "-s")):
-    """Generate API client from OpenAPI schema"""
-    if not schema_path.exists():
-        typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
-        raise typer.Exit(1)
-    from .utils.openapi import generate_api_client, load_schema
-
-    try:
-        schema = load_schema(schema_path)
-    except Exception as e:
-        typer.echo(f"Error loading schema: {e}", err=True)
-        raise typer.Exit(1)
-    code = generate_api_client(schema)
-    print(code)
-
-@app.command()
-def run():
-    """Run the MCP server"""
-    from agentr.test import mcp
-    mcp.run()
-
-@app.command()
-def install(app_name: str):
-    """Install an app"""
-    import json
-
-    # Print instructions before asking for API key
-    typer.echo("╭─ Instruction ─────────────────────────────────────────────────────────────────╮")
-    typer.echo("│ API key is required. Visit https://agentr.dev to create an API key.           │")
-    typer.echo("╰───────────────────────────────────────────────────────────────────────────────╯")
-    # Prompt for API key
-    api_key = typer.prompt("Enter your AgentR API key", hide_input=True)
-
-    if app_name == "claude":
-        typer.echo(f"Installing mcp server for: {app_name}")
-
-        # Determine platform-specific config path
-        if sys.platform == "darwin":  # macOS
-            config_path = Path.home() / "Library/Application Support/Claude/claude_desktop_config.json"
-        elif sys.platform == "win32":  # Windows
-            config_path = Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
-        else:
-            typer.echo("Unsupported platform. Only macOS and Windows are currently supported.", err=True)
-            raise typer.Exit(1)
-        
-        
-        with open(config_path, 'r') as f:
-            config = json.load(f)
-        config['mcpServers']['agentr-r'] = {
-            "command": "uvx",
-            "args": ["agentr@latest", "run"],
-            "env": {
-                "AGENTR_API_KEY": api_key
-            }
-        }
-        with open(config_path, 'w') as f:
-            json.dump(config, f, indent=4)
-        typer.echo("App installed successfully")
-    else:
-        typer.echo(f"App {app_name} not supported")
-
-if __name__ == "__main__":
-    app()
+import typer
+from pathlib import Path
+import sys
+
+app = typer.Typer()
+
+@app.command()
+def version():
+    """Show the version of the CLI"""
+    print("agentr version 0.1.0")
+
+@app.command()
+def generate(schema_path: Path = typer.Option(..., "--schema", "-s")):
+    """Generate API client from OpenAPI schema"""
+    if not schema_path.exists():
+        typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
+        raise typer.Exit(1)
+    from .utils.openapi import generate_api_client, load_schema
+
+    try:
+        schema = load_schema(schema_path)
+    except Exception as e:
+        typer.echo(f"Error loading schema: {e}", err=True)
+        raise typer.Exit(1)
+    code = generate_api_client(schema)
+    print(code)
+
+@app.command()
+def run():
+    """Run the MCP server"""
+    from agentr.server import AgentRServer
+    mcp = AgentRServer(name="AgentR Server", description="AgentR Server")
+    mcp.run()
+
+@app.command()
+def install(app_name: str):
+    """Install an app"""
+    import json
+
+    # Print instructions before asking for API key
+    typer.echo("╭─ Instruction ─────────────────────────────────────────────────────────────────╮")
+    typer.echo("│ API key is required. Visit https://agentr.dev to create an API key.           │")
+    typer.echo("╰───────────────────────────────────────────────────────────────────────────────╯")
+    # Prompt for API key
+    api_key = typer.prompt("Enter your AgentR API key", hide_input=True)
+
+    if app_name == "claude":
+        typer.echo(f"Installing mcp server for: {app_name}")
+
+        # Determine platform-specific config path
+        if sys.platform == "darwin":  # macOS
+            config_path = Path.home() / "Library/Application Support/Claude/claude_desktop_config.json"
+        elif sys.platform == "win32":  # Windows
+            config_path = Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
+        else:
+            typer.echo("Unsupported platform. Only macOS and Windows are currently supported.", err=True)
+            raise typer.Exit(1)
+        
+        
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        config['mcpServers']['agentr'] = {
+            "command": "uvx",
+            "args": ["agentr@latest", "run"],
+            "env": {
+                "AGENTR_API_KEY": api_key
+            }
+        }
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=4)
+        typer.echo("App installed successfully")
+    else:
+        typer.echo(f"App {app_name} not supported")
+
+if __name__ == "__main__":
+    app()

agentr/config.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from typing import Literal
+
+class StoreConfig(BaseModel):
+    type: Literal["memory", "environment"]
+
+class IntegrationConfig(BaseModel):
+    name: str
+    type: Literal["api_key", "agentr"]
+    credentials: dict | None = None
+    store: StoreConfig | None = None
+
+class AppConfig(BaseModel):
+    name: str
+    integration: IntegrationConfig | None = None

agentr/exceptions.py

@@ -1,5 +1,6 @@
-class NotAuthorizedError(Exception):
-    """Raised when a user is not authorized to access a resource or perform an action."""
-    def __init__(self, message="Not authorized to perform this action"):
-        self.message = message
-        super().__init__(self.message)
+class NotAuthorizedError(Exception):
+    """Raised when a user is not authorized to access a resource or perform an action."""
+    def __init__(self, message="Not authorized to perform this action"):
+        self.message = message
+        super().__init__(self.message)
+

agentr/integration.py

@@ -1,98 +1,161 @@
-from abc import ABC, abstractmethod
-import os
-import sys
-
-from loguru import logger
-from agentr.store import Store
-import httpx
-
-"""
-Integration defines how a Application needs to authorize.
-It is responsible for authenticating application with the service provider.
-Supported integrations:
-- AgentR Integration
-- API Key Integration
-"""
-
-class Integration(ABC):
-    def __init__(self, name: str, store: Store = None):
-        self.name = name
-        self.store = store
-
-    @abstractmethod
-    def get_credentials(self):
-        pass
-
-    @abstractmethod
-    def set_credentials(self, credentials: dict):
-        pass
-
-class ApiKeyIntegration(Integration):
-    def __init__(self, name: str, store: Store = None, **kwargs):
-        super().__init__(name, store, **kwargs)
-
-    def get_credentials(self):
-        credentials = self.store.get(self.name)
-        return credentials
-
-    def set_credentials(self, credentials: dict):
-        self.store.set(self.name, credentials)
-
-    def authorize(self):
-        return {"text": "Please configure the environment variable {self.name}_API_KEY"}
-
-
-
-class AgentRIntegration(Integration):
-    def __init__(self, name: str, api_key: str = None, **kwargs):
-        super().__init__(name, **kwargs)
-        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
-        if not self.api_key:
-            logger.error("API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable.")
-            raise ValueError("AgentR API key required - get one at https://agentr.dev")
-
-        self.base_url = "https://auth.agentr.dev"
-        self.user_id = "default"
-    
-    def _create_session_token(self):
-        url = "https://auth.agentr.dev/connect/sessions"
-        body = {
-            "end_user": {
-                "id": self.user_id,
-            },
-            "allowed_integrations": [self.name]
-        }
-        response = httpx.post(url, headers={"Authorization": f"Bearer {self.api_key}"}, json=body)
-        data = response.json()
-        print(data)
-        return data["data"]["token"]
-    
-    def _get_authorize_url(self):
-        session_token = self._create_session_token()
-        return f"https://auth.agentr.dev/oauth/connect/{self.name}?connect_session_token={session_token}"
-    
-    def get_connection_by_owner(self):
-        url = f"https://auth.agentr.dev/connection?endUserId={self.user_id}"
-        response = httpx.get(url, headers={"Authorization": f"Bearer {self.api_key}"})
-        if response.status_code == 200:
-            connections = response.json()["connections"]
-            for connection in connections:
-                if connection["provider_config_key"] == self.name:
-                    return connection["connection_id"]
-        return None
-
-    def set_credentials(self, credentials: dict):
-        raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
-
-    def get_credentials(self):
-        connection_id = self.get_connection_by_owner()
-        logger.info(f"Connection ID: {connection_id}")
-        if connection_id:
-            response = httpx.get(f"{self.base_url}/connection/{connection_id}?provider_config_key={self.name}", headers={"Authorization": f"Bearer {self.api_key}"})
-            data = response.json()
-            return data.get("credentials")
-        return None
-
-    def authorize(self):
-        url = self._get_authorize_url()
-        return f"Please authorize the application by clicking the link {url}"
+from abc import ABC, abstractmethod
+import os
+
+from loguru import logger
+from agentr.exceptions import NotAuthorizedError
+from agentr.store import Store
+import httpx
+
+"""
+Integration defines how a Application needs to authorize.
+It is responsible for authenticating application with the service provider.
+Supported integrations:
+- AgentR Integration
+- API Key Integration
+"""
+
+
+class Integration(ABC):
+    """Abstract base class for handling application integrations and authentication.
+    
+    This class defines the interface for different types of integrations that handle
+    authentication and authorization with external services.
+    
+    Args:
+        name: The name identifier for this integration
+        store: Optional Store instance for persisting credentials and other data
+    
+    Attributes:
+        name: The name identifier for this integration
+        store: Store instance for persisting credentials and other data
+    """
+    def __init__(self, name: str, store: Store = None):
+        self.name = name
+        self.store = store
+
+    @abstractmethod
+    def authorize(self):
+        """Authorize the integration.
+        
+        Returns:
+            str: Authorization URL.
+        """
+        pass
+    
+    @abstractmethod
+    def get_credentials(self):
+        """Get credentials for the integration.
+        
+        Returns:
+            dict: Credentials for the integration.
+        
+        Raises:
+            NotAuthorizedError: If credentials are not found.
+        """
+        pass
+
+    @abstractmethod
+    def set_credentials(self, credentials: dict):
+        """Set credentials for the integration.
+        
+        Args:
+            credentials: Credentials for the integration.
+        """
+        pass
+
+class ApiKeyIntegration(Integration):
+    def __init__(self, name: str, store: Store = None, **kwargs):
+        super().__init__(name, store, **kwargs)
+
+    def get_credentials(self):
+        credentials = self.store.get(self.name)
+        return credentials
+
+    def set_credentials(self, credentials: dict):
+        self.store.set(self.name, credentials)
+
+    def authorize(self):
+        return {"text": "Please configure the environment variable {self.name}_API_KEY"}
+
+
+class AgentRIntegration(Integration):
+    """Integration class for AgentR API authentication and authorization.
+    
+    This class handles API key authentication and OAuth authorization flow for AgentR services.
+    
+    Args:
+        name (str): Name of the integration
+        api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var
+        **kwargs: Additional keyword arguments passed to parent Integration class
+        
+    Raises:
+        ValueError: If no API key is provided or found in environment variables
+    """
+    def __init__(self, name: str, api_key: str = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if not self.api_key:
+            logger.error("API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable.")
+            raise ValueError("AgentR API key required - get one at https://agentr.dev")
+        self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+    
+    def set_credentials(self, credentials: dict| None = None):
+        """Set credentials for the integration.
+        
+        This method is not implemented for AgentR integration. Instead it redirects to the authorize flow.
+        
+        Args:
+            credentials (dict | None, optional): Credentials dict (not used). Defaults to None.
+            
+        Returns:
+            str: Authorization URL from authorize() method
+        """
+        return self.authorize()
+        # raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
+
+    def get_credentials(self):
+        """Get credentials for the integration from the AgentR API.
+        
+        Makes API request to retrieve stored credentials for this integration.
+        
+        Returns:
+            dict: Credentials data from API response
+            
+        Raises:
+            NotAuthorizedError: If credentials are not found (404 response)
+            HTTPError: For other API errors
+        """
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/credentials/",
+            headers={
+                "accept": "application/json",
+                "X-API-KEY": self.api_key
+            }
+        )
+        if response.status_code == 404:
+            action = self.authorize()
+            raise NotAuthorizedError(action)
+        response.raise_for_status()
+        data = response.json()
+        return data
+
+    def authorize(self):
+        """Get authorization URL for the integration.
+        
+        Makes API request to get OAuth authorization URL.
+        
+        Returns:
+            str: Message containing authorization URL
+            
+        Raises:
+            HTTPError: If API request fails
+        """
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/authorize/",
+            headers={
+                "X-API-KEY": self.api_key
+            }
+        )
+        response.raise_for_status()
+        url = response.json()
+        return f"Please authorize the application by clicking the link {url}"

agentr/integrations/README.md

@@ -0,0 +1,25 @@
+# Integrations
+
+This package provides integration classes for handling authentication and authorization with external services.
+
+## Overview
+
+An Integration defines how an application authenticates and authorizes with a service provider. The base `Integration` class provides an interface that all integrations must implement.
+
+## Supported Integrations
+
+### AgentR Integration
+The `AgentRIntegration` class handles OAuth-based authentication flow with the AgentR API. It requires an API key which can be obtained from [agentr.dev](https://agentr.dev).
+
+### API Key Integration  
+The `ApiKeyIntegration` class provides a simple API key based authentication mechanism. API keys are configured via environment variables.
+
+## Usage
+
+Each integration implements three key methods:
+
+- `authorize()` - Initiates the authorization flow
+- `get_credentials()` - Retrieves stored credentials
+- `set_credentials()` - Stores new credentials
+
+See the individual integration classes for specific usage details.

agentr/integrations/__init__.py

@@ -0,0 +1,5 @@
+from agentr.integrations.agentr import AgentRIntegration
+from agentr.integrations.base import Integration
+from agentr.integrations.api_key import ApiKeyIntegration
+
+__all__ = ["AgentRIntegration", "Integration", "ApiKeyIntegration"]

agentr/integrations/agentr.py

@@ -0,0 +1,87 @@
+from agentr.integrations.base import Integration
+import os
+import httpx
+from loguru import logger
+from agentr.exceptions import NotAuthorizedError
+
+class AgentRIntegration(Integration):
+    """Integration class for AgentR API authentication and authorization.
+    
+    This class handles API key authentication and OAuth authorization flow for AgentR services.
+    
+    Args:
+        name (str): Name of the integration
+        api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var
+        **kwargs: Additional keyword arguments passed to parent Integration class
+        
+    Raises:
+        ValueError: If no API key is provided or found in environment variables
+    """
+    def __init__(self, name: str, api_key: str = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if not self.api_key:
+            logger.error("API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable.")
+            raise ValueError("AgentR API key required - get one at https://agentr.dev")
+        self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+    
+    def set_credentials(self, credentials: dict| None = None):
+        """Set credentials for the integration.
+        
+        This method is not implemented for AgentR integration. Instead it redirects to the authorize flow.
+        
+        Args:
+            credentials (dict | None, optional): Credentials dict (not used). Defaults to None.
+            
+        Returns:
+            str: Authorization URL from authorize() method
+        """
+        return self.authorize()
+        # raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
+
+    def get_credentials(self):
+        """Get credentials for the integration from the AgentR API.
+        
+        Makes API request to retrieve stored credentials for this integration.
+        
+        Returns:
+            dict: Credentials data from API response
+            
+        Raises:
+            NotAuthorizedError: If credentials are not found (404 response)
+            HTTPError: For other API errors
+        """
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/credentials/",
+            headers={
+                "accept": "application/json",
+                "X-API-KEY": self.api_key
+            }
+        )
+        if response.status_code == 404:
+            action = self.authorize()
+            raise NotAuthorizedError(action)
+        response.raise_for_status()
+        data = response.json()
+        return data
+
+    def authorize(self):
+        """Get authorization URL for the integration.
+        
+        Makes API request to get OAuth authorization URL.
+        
+        Returns:
+            str: Message containing authorization URL
+            
+        Raises:
+            HTTPError: If API request fails
+        """
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/authorize/",
+            headers={
+                "X-API-KEY": self.api_key
+            }
+        )
+        response.raise_for_status()
+        url = response.json()
+        return f"Please authorize the application by clicking the link {url}"

agentr/integrations/api_key.py

@@ -0,0 +1,16 @@
+from agentr.integrations.base import Integration
+from agentr.store import Store
+
+class ApiKeyIntegration(Integration):
+    def __init__(self, name: str, store: Store = None, **kwargs):
+        super().__init__(name, store, **kwargs)
+
+    def get_credentials(self):
+        credentials = self.store.get(self.name)
+        return credentials
+
+    def set_credentials(self, credentials: dict):
+        self.store.set(self.name, credentials)
+
+    def authorize(self):
+        return {"text": "Please configure the environment variable {self.name}_API_KEY"}

agentr/integrations/base.py

@@ -0,0 +1,60 @@
+from abc import ABC, abstractmethod
+import os
+
+from loguru import logger
+from agentr.exceptions import NotAuthorizedError
+from agentr.store import Store
+import httpx
+
+
+
+
+class Integration(ABC):
+    """Abstract base class for handling application integrations and authentication.
+    
+    This class defines the interface for different types of integrations that handle
+    authentication and authorization with external services.
+    
+    Args:
+        name: The name identifier for this integration
+        store: Optional Store instance for persisting credentials and other data
+    
+    Attributes:
+        name: The name identifier for this integration
+        store: Store instance for persisting credentials and other data
+    """
+    def __init__(self, name: str, store: Store = None):
+        self.name = name
+        self.store = store
+
+    @abstractmethod
+    def authorize(self):
+        """Authorize the integration.
+        
+        Returns:
+            str: Authorization URL.
+        """
+        pass
+    
+    @abstractmethod
+    def get_credentials(self):
+        """Get credentials for the integration.
+        
+        Returns:
+            dict: Credentials for the integration.
+        
+        Raises:
+            NotAuthorizedError: If credentials are not found.
+        """
+        pass
+
+    @abstractmethod
+    def set_credentials(self, credentials: dict):
+        """Set credentials for the integration.
+        
+        Args:
+            credentials: Credentials for the integration.
+        """
+        pass
+
+