agentr 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

agentr/applications/tavily/app.py

@@ -1,57 +1,57 @@
-from agentr.application import APIApplication
-from agentr.integration import Integration
-
-class TavilyApp(APIApplication):
-    def __init__(self, integration: Integration) -> None:
-        name = "tavily"
-        self.base_url = "https://api.tavily.com"
-        super().__init__(name=name, integration=integration)
-    
-    def _get_headers(self):
-        credentials = self.integration.get_credentials()
-        if not credentials:
-            raise ValueError("No credentials found")
-        return {
-            "Authorization": f"Bearer {credentials['api_key']}",
-            "Content-Type": "application/json"
-        }
-
-    def search(self, query: str) -> str:
-        """Search the web using Tavily's search API
-        
-        Args:
-            query: The search query
-            
-        Returns:
-            str: A summary of search results
-        """
-        self.validate()
-        url = f"{self.base_url}/search"
-        payload = {
-            "query": query,
-            "topic": "general",
-            "search_depth": "basic",
-            "max_results": 3,
-            "include_answer": True,
-            "include_raw_content": False,
-            "include_images": False,
-            "include_image_descriptions": False,
-            "include_domains": [],
-            "exclude_domains": []
-        }
-        
-        response = self._post(url, payload)
-        result = response.json()
-        
-        if "answer" in result:
-            return result["answer"]
-        
-        # Fallback to combining top results if no direct answer
-        summaries = []
-        for item in result.get("results", [])[:3]:
-            summaries.append(f"• {item['title']}: {item['snippet']}")
-        
-        return "\n".join(summaries)
-    
-    def list_tools(self):
-        return [self.search]
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class TavilyApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        name = "tavily"
+        self.base_url = "https://api.tavily.com"
+        super().__init__(name=name, integration=integration)
+    
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        return {
+            "Authorization": f"Bearer {credentials['api_key']}",
+            "Content-Type": "application/json"
+        }
+
+    def search(self, query: str) -> str:
+        """Search the web using Tavily's search API
+        
+        Args:
+            query: The search query
+            
+        Returns:
+            str: A summary of search results
+        """
+        self.validate()
+        url = f"{self.base_url}/search"
+        payload = {
+            "query": query,
+            "topic": "general",
+            "search_depth": "basic",
+            "max_results": 3,
+            "include_answer": True,
+            "include_raw_content": False,
+            "include_images": False,
+            "include_image_descriptions": False,
+            "include_domains": [],
+            "exclude_domains": []
+        }
+        
+        response = self._post(url, payload)
+        result = response.json()
+        
+        if "answer" in result:
+            return result["answer"]
+        
+        # Fallback to combining top results if no direct answer
+        summaries = []
+        for item in result.get("results", [])[:3]:
+            summaries.append(f"• {item['title']}: {item['snippet']}")
+        
+        return "\n".join(summaries)
+    
+    def list_tools(self):
+        return [self.search]

agentr/applications/zenquotes/app.py

@@ -1,21 +1,21 @@
-from agentr.application import APIApplication
-
-
-class ZenQuoteApp(APIApplication):
-    def __init__(self, **kwargs) -> None:
-        super().__init__(name="zenquote", **kwargs)
-
-    def get_quote(self) -> str:
-        """Get an inspirational quote from the Zen Quotes API
-        
-        Returns:
-            A random inspirational quote
-        """
-        url = "https://zenquotes.io/api/random"
-        response = self._get(url)
-        data = response.json()
-        quote_data = data[0]
-        return f"{quote_data['q']} - {quote_data['a']}"
-
-    def list_tools(self):
+from agentr.application import APIApplication
+
+
+class ZenQuoteApp(APIApplication):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(name="zenquote", **kwargs)
+
+    def get_quote(self) -> str:
+        """Get an inspirational quote from the Zen Quotes API
+        
+        Returns:
+            A random inspirational quote
+        """
+        url = "https://zenquotes.io/api/random"
+        response = self._get(url)
+        data = response.json()
+        quote_data = data[0]
+        return f"{quote_data['q']} - {quote_data['a']}"
+
+    def list_tools(self):
         return [self.get_quote]

agentr/cli.py

@@ -1,58 +1,75 @@
-import typer
-from pathlib import Path
-
-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
-    api_key = typer.prompt("Enter your API key", hide_input=True)
-    if app_name == "claude":
-        typer.echo(f"Installing mcp server for: {app_name}")
-        config_path = '~/Library/Application Support/Claude/claude_desktop_config.json'
-        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.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()

agentr/exceptions.py

@@ -0,0 +1,5 @@
+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,91 +1,98 @@
-from abc import ABC, abstractmethod
-import os
-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 NangoIntegration(Integration):
-    def __init__(self, user_id, integration_id):
-        self.integration_id = integration_id
-        self.user_id = user_id
-        self.nango_secret_key = os.getenv("NANGO_SECRET_KEY")
-
-    def _create_session_token(self):
-        url = "https://api.nango.dev/connect/sessions"
-        body = {
-            "end_user": {
-                "id": self.user_id,
-            },
-            "allowed_integrations": [self.integration_id]
-        }
-        response = httpx.post(url, headers={"Authorization": f"Bearer {self.nango_secret_key}"}, json=body)
-        data = response.json()
-        return data["data"]["token"]
-    
-    def get_authorize_url(self):
-        session_token = self._create_session_token()
-        return f"https://api.nango.dev/oauth/connect/{self.integration_id}?connect_session_token={session_token}"
-
-    def get_connection_by_owner(self, user_id):
-        url = f"https://api.nango.dev/connection?endUserId={user_id}"
-        response = httpx.get(url, headers={"Authorization": f"Bearer {self.nango_secret_key}"})
-        if response.status_code == 200:
-            connections = response.json()["connections"]
-            for connection in connections:
-                if connection["provider_config_key"] == self.integration_id:
-                    return connection["connection_id"]
-        return None
-
-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:
-            raise ValueError("api_key is required")
-        self.base_url = "https://api.agentr.dev"
-        self.user_id = "default"
-
-    def get_credentials(self):
-        response = httpx.get(f"{self.base_url}/integrations/{self.name}/credentials", headers={"Authorization": f"Bearer {self.api_key}"})
-        return response.json()
-
-    def authorize(self):
-        response = httpx.post(f"{self.base_url}/integrations/{self.name}/authorize", headers={"Authorization": f"Bearer {self.api_key}"})
-        url = response.json()["url"]
-        return {"url": url, "text": "Please authorize the application by clicking the link {url}"}
+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}"