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

agentr/application.py

@@ -1,8 +1,11 @@
 from abc import ABC, abstractmethod
-from agentr.store import Store
+from agentr.integration import Integration
 import httpx
 
 class Application(ABC):
+    """
+    Application is collection of tools that can be used by an agent.
+    """
     def __init__(self, name: str, **kwargs):
         self.name = name
 
@@ -12,9 +15,12 @@ class Application(ABC):
 
 
 class APIApplication(Application):
-    def __init__(self, name: str, store: Store, **kwargs):
+    """
+    APIApplication is an application that uses an API to interact with the world.
+    """
+    def __init__(self, name: str, integration: Integration = None, **kwargs):
         super().__init__(name, **kwargs)
-        self.store = store
+        self.integration = integration
 
     def _get_headers(self):
         return {}
@@ -22,29 +28,30 @@ class APIApplication(Application):
     def _get(self, url, params=None):
         headers = self._get_headers()
         response = httpx.get(url, headers=headers, params=params)
+        response.raise_for_status()
         return response
     
     def _post(self, url, data):
         headers = self._get_headers()
-        response = httpx.post(url, headers=headers, data=data)
+        response = httpx.post(url, headers=headers, json=data)
+        response.raise_for_status()
         return response
 
     def _put(self, url, data):
         headers = self._get_headers()
-        response = httpx.put(url, headers=headers, data=data)
+        response = httpx.put(url, headers=headers, json=data)
+        response.raise_for_status()
         return response
 
     def _delete(self, url):
         headers = self._get_headers()
         response = httpx.delete(url, headers=headers)
+        response.raise_for_status()
         return response
 
     def validate(self):
         pass
     
-    def authorize(self):
-        pass
-
     @abstractmethod
     def list_tools(self):
         pass

agentr/applications/github/app.py

@@ -0,0 +1,52 @@
+from agentr.integration import Integration
+from agentr.application import APIApplication
+from loguru import logger
+
+
+class GithubApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="github", integration=integration)
+
+    def _get_headers(self):
+        if not self.integration:
+            raise ValueError("Integration not configured")
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            logger.warning("No credentials found")
+            return self.integration.authorize()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+    
+
+    def star_repository(self, repo_full_name: str) -> str:
+        """Star a GitHub repository
+        
+            Args:
+                repo_full_name: The full name of the repository (e.g. 'owner/repo')
+                
+            Returns:
+            
+                A confirmation message
+        """
+        try:
+            url = f"https://api.github.com/user/starred/{repo_full_name}"
+            response = self._put(url, data={})
+            
+            if response.status_code == 204:
+                return f"Successfully starred repository {repo_full_name}"
+            elif response.status_code == 404:
+                return f"Repository {repo_full_name} not found"
+            else:
+                logger.error(response.text)
+                return f"Error starring repository: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error starring repository: {e}"
+
+    
+    def list_tools(self):
+        return [self.star_repository]

agentr/applications/google_calendar/app.py

@@ -0,0 +1,74 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+from loguru import logger
+from datetime import datetime, timedelta
+
+class GoogleCalendarApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="google-calendar", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/json"
+        }
+    
+    
+    def get_today_events(self) -> str:
+        """Get events from your Google Calendar for today
+        
+        Returns:
+            A formatted list of today's events or an error message
+        """
+        if not self.validate():
+            logger.warning("Connection not configured correctly")
+            return self.authorize()
+        
+        try:
+            # Get today's date in ISO format
+            today = datetime.now().date()
+            tomorrow = today + timedelta(days=1)
+            
+            # Format dates for API
+            time_min = f"{today.isoformat()}T00:00:00Z"
+            time_max = f"{tomorrow.isoformat()}T00:00:00Z"
+            
+            url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
+            params = {
+                "timeMin": time_min,
+                "timeMax": time_max,
+                "singleEvents": "true",
+                "orderBy": "startTime"
+            }
+            
+            response = self._get(url, params=params)
+            
+            if response.status_code == 200:
+                events = response.json().get("items", [])
+                if not events:
+                    return "No events scheduled for today."
+                
+                result = "Today's events:\n\n"
+                for event in events:
+                    start = event.get("start", {})
+                    start_time = start.get("dateTime", start.get("date", "All day"))
+                    if "T" in start_time:  # Format datetime
+                        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                        start_time = start_dt.strftime("%I:%M %p")
+                    
+                    summary = event.get("summary", "Untitled event")
+                    result += f"- {start_time}: {summary}\n"
+                
+                return result
+            else:
+                logger.error(response.text)
+                return f"Error retrieving calendar events: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error retrieving calendar events: {e}"
+    
+    def list_tools(self):
+        return [self.get_today_events]

agentr/applications/google_mail/app.py

@@ -0,0 +1,68 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+from loguru import logger
+import base64
+from email.message import EmailMessage
+
+class GmailApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="gmail", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            'Content-Type': 'application/json'
+        }
+
+    def send_email(self, to: str, subject: str, body: str) -> str:
+        """Send an email
+        
+        Args:
+            to: The email address of the recipient
+            subject: The subject of the email
+            body: The body of the email
+            
+        Returns:
+        
+            A confirmation message
+        """
+        if not self.validate():
+            logger.warning("Connection not configured correctly")
+            return self.authorize()
+        try:
+            url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+            
+            # Create email in base64 encoded format
+            email_message = {
+                "raw": self._create_message(to, subject, body)
+            }
+            logger.info(email_message)
+            
+            # Use json parameter instead of data to properly format JSON
+            response = self._post(url, email_message)
+            
+            if response.status_code == 200:
+                return f"Successfully sent email to {to}"
+            else:
+                logger.error(response.text)
+                return f"Error sending email: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error sending email: {e}"
+            
+    def _create_message(self, to, subject, body):
+        message = EmailMessage()
+        message['to'] = to
+        message['from'] = "manojbajaj95@gmail.com"
+        message['subject'] = subject
+        message.set_content(body)
+        
+        # Encode as base64 string
+        raw = base64.urlsafe_b64encode(message.as_bytes()).decode()
+        return raw
+    
+    def list_tools(self):
+        return [self.send_email]

agentr/applications/reddit/app.py

@@ -0,0 +1,29 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class RedditApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="reddit", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+        }
+
+    def get_subreddit_posts(self, subreddit: str) -> str:
+        """Get the latest posts from a subreddit
+        
+        Args:
+            subreddit: The subreddit to get posts from
+            
+        Returns:
+            A list of posts from the subreddit
+        """
+        
+
+    def list_tools(self):
+        return []
+    

agentr/applications/resend/app.py

@@ -0,0 +1,43 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class ResendApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="resend", 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']}",
+        }
+
+    def send_email(self, to: str, subject: str, content: str) -> str:
+        """Send an email using the Resend API
+
+        Args:
+            to: The email address to send the email to
+            subject: The subject of the email
+            content: The content of the email
+            
+        Returns:
+            A message indicating that the email was sent successfully
+        """
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        from_email = credentials.get("from_email", "Manoj <manoj@agentr.dev>")
+        url = "https://api.resend.com/emails"
+        body = {
+            "from": from_email,
+            "to": [to],
+            "subject": subject,
+            "text": content
+        }
+        self._post(url, body)
+        return "Sent Successfully"
+
+    def list_tools(self):
+        return [self.send_email]
+

agentr/applications/tavily/app.py

@@ -0,0 +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]

agentr/cli.py

@@ -1,5 +1,4 @@
 import typer
-import yaml
 from pathlib import Path
 
 app = typer.Typer()
@@ -28,8 +27,32 @@ def generate(schema_path: Path = typer.Option(..., "--schema", "-s")):
 @app.command()
 def run():
     """Run the MCP server"""
-    from agentr.mcp import mcp
+    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()

agentr/integration.py

@@ -0,0 +1,91 @@
+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}"}

agentr/server.py

@@ -1,8 +1,23 @@
 from abc import ABC, abstractmethod
+from typing import Literal
 from mcp.server.fastmcp import FastMCP
+from agentr.integration import AgentRIntegration, ApiKeyIntegration
+from agentr.store import EnvironmentStore, MemoryStore
+from pydantic import BaseModel
+from loguru import logger
 
-from agentr.applications.zenquotes.app import ZenQuoteApp
-from agentr.store import Store
+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
 
 class Server(FastMCP, ABC):
     """
@@ -10,24 +25,81 @@ class Server(FastMCP, ABC):
     It also acts as a router for the applications, and exposed to the client
 
     """
-    def __init__(self, name: str, description: str, store: Store, **kwargs):
-        self.store = store
+    def __init__(self, name: str, description: str, **kwargs):
         super().__init__(name, description, **kwargs)
 
+    @abstractmethod
+    def _load_apps(self):
+        pass
+
 
 class TestServer(Server):
     """
     Test server for development purposes
     """
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.apps_list = ["zenquotes"]
-        self.__load_apps()
-
-    def __load_apps(self):
-        self.apps = []
-        for app in self.apps_list:
-            if app == "zenquotes":
-                app = ZenQuoteApp(store=self.store)
+    def __init__(self, name: str, description: str, apps_list: list[AppConfig] = [], **kwargs):
+        super().__init__(name, description=description, **kwargs)
+        self.apps_list = [AppConfig.model_validate(app) for app in apps_list]
+        self._load_apps()
+    
+    def _get_store(self, store_config: StoreConfig):
+        if store_config.type == "memory":
+            return MemoryStore()
+        elif store_config.type == "environment":
+            return EnvironmentStore()
+        return None
+
+    def _get_integration(self, integration_config: IntegrationConfig):
+        if integration_config.type == "api_key":
+            store = self._get_store(integration_config.store)
+            integration = ApiKeyIntegration(integration_config.name, store=store)
+            if integration_config.credentials:
+                integration.set_credentials(integration_config.credentials)
+            return integration
+        elif integration_config.type == "agentr":
+            integration = AgentRIntegration(integration_config.name, api_key=integration_config.credentials.get("api_key") if integration_config.credentials else None)
+            return integration
+        return None
+    
+    def _load_app(self, app_config: AppConfig):
+        name = app_config.name
+        if name == "zenquotes":
+            from agentr.applications.zenquotes.app import ZenQuoteApp
+            return ZenQuoteApp()
+        elif name == "tavily":
+            from agentr.applications.tavily.app import TavilyApp
+            integration = self._get_integration(app_config.integration)
+            return TavilyApp(integration=integration)
+        elif name == "github":
+            from agentr.applications.github.app import GithubApp
+            integration = self._get_integration(app_config.integration)
+            return GithubApp(integration=integration)
+        elif name == "google-calendar":
+            from agentr.applications.google_calendar.app import GoogleCalendarApp
+            integration = self._get_integration(app_config.integration)
+            return GoogleCalendarApp(integration=integration)
+        elif name == "gmail":
+            from agentr.applications.google_mail.app import GmailApp
+            integration = self._get_integration(app_config.integration)
+            return GmailApp(integration=integration)
+        elif name == "resend":
+            from agentr.applications.resend.app import ResendApp
+            integration = self._get_integration(app_config.integration)
+            return ResendApp(integration=integration)
+        elif name == "reddit":
+            from agentr.applications.reddit.app import RedditApp
+            integration = self._get_integration(app_config.integration)
+            return RedditApp(integration=integration)
+        else:
+            return None
+            
+    def _load_apps(self):
+        logger.info(f"Loading apps: {self.apps_list}")
+        for app_config in self.apps_list:
+            app = self._load_app(app_config)
+            if app:
                 tools = app.list_tools()
-                self.add_tool(tools[0])
+                for tool in tools:
+                    self.add_tool(tool)
+
+                

agentr/store.py

@@ -1,4 +1,4 @@
-
+import os
 from abc import ABC, abstractmethod
 
 
@@ -33,3 +33,39 @@ class MemoryStore:
     def delete(self, key: str):
         del self.data[key]
 
+
+class EnvironmentStore(Store):
+    """
+    Store that uses environment variables to store credentials.
+    """
+    def __init__(self):
+        pass
+
+    def get(self, key: str):
+        return {"api_key": os.getenv(key)}
+
+    def set(self, key: str, value: str):
+        os.environ[key] = value
+
+    def delete(self, key: str):
+        del os.environ[key]
+
+class RedisStore(Store):
+    """
+    Store that uses a redis database to store credentials.
+    """
+    def __init__(self, host: str, port: int, db: int):
+        import redis
+        self.host = host
+        self.port = port
+        self.db = db
+        self.redis = redis.Redis(host=self.host, port=self.port, db=self.db)
+
+    def get(self, key: str):
+        return self.redis.get(key)
+
+    def set(self, key: str, value: str):
+        self.redis.set(key, value)
+
+    def delete(self, key: str):
+        self.redis.delete(key)

agentr/test.py

@@ -0,0 +1,38 @@
+from agentr.server import TestServer
+from agentr.store import MemoryStore
+
+store = MemoryStore()
+apps_list = [
+    {
+        "name": "tavily",
+        "integration": {
+            "name": "tavily_api_key",
+            "type": "api_key",
+            "store": {
+                "type": "environment",
+            }
+        },        
+    },
+    {
+        "name": "zenquotes",
+        "integration": None
+    },
+    {
+        "name": "github",
+        "integration": {
+            "name": "github",
+            "type": "agentr",
+        }
+    }
+]
+mcp = TestServer(name="Test Server", description="Test Server", apps_list=apps_list)
+
+async def test():
+    tools = await mcp.list_tools()
+    print(tools)
+    result = await mcp.call_tool("search", {"query": "python"})
+    print(result)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test())

{agentr-0.1.2.dist-info → agentr-0.1.3.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: agentr
-Version: 0.1.2
+Version: 0.1.3
 Summary: Add your description here
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 Requires-Python: >=3.11
+Requires-Dist: loguru>=0.7.3
 Requires-Dist: mcp>=1.5.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: typer>=0.15.2

agentr-0.1.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+agentr/__init__.py,sha256=LOWhgQayrQV7f5ro4rlBJ_6WevhbWIbjAOHnqP7b_-4,30
+agentr/application.py,sha256=2K7jL5QUDwlD_zRS7adN_R3_yPt-EJBYpAmr1abDew8,1551
+agentr/cli.py,sha256=KcmYrnzoVzkh4SWB6UDjxGJboQbMcphj1juNbfqrIAE,1676
+agentr/integration.py,sha256=jRwpp_bUXJWl8OkZsnRDqoScoRSxCMDBMrDMfRBhgN4,3298
+agentr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentr/server.py,sha256=24cD8e3ks8ckftPMphI7K3SfGs8LZZyXpfiKU2daY-Q,4220
+agentr/store.py,sha256=fB3uAaobnWf2ILcDBmg3ToDaqAIPYlLtmHBdpmkcGcI,1585
+agentr/test.py,sha256=A0t1fdI9N89eF9xm903fKtvTzibnrHeMKkPwZnSBEc4,852
+agentr/applications/github/app.py,sha256=_PW_xzkCzNB468lEOvFzdQk0m7Ol6y_PQ5OqCkVkDVE,1811
+agentr/applications/google_calendar/app.py,sha256=WW-4MTqPl-NU2w5DKKyEvfTho4d6tS7t52jDRyq-tv0,2841
+agentr/applications/google_mail/app.py,sha256=SqzWyYW0xF_fdZC8kf_8FZfQK6OOddI-EVpdgYAengg,2334
+agentr/applications/reddit/app.py,sha256=iNkSRVGScj7Mae3e8N-Mkov_hvZrvH5NynbpO8mKToQ,842
+agentr/applications/resend/app.py,sha256=ihRzP65bwoNIq3EzBqIghxgLZRxvy-LbHy-rER20ODo,1428
+agentr/applications/tavily/app.py,sha256=D4FOhm2yxNbuTVHTo3T8ZsuE5AgwK874YutfYx2Njcw,1805
+agentr/applications/zenquotes/app.py,sha256=4LjYeWdERI8ZMzkajOsDgy9IRTA9plUKem-rW4M03sA,607
+agentr/utils/bridge.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentr/utils/openapi.py,sha256=yjiPYs-_JsYQ7T3aPh7oimHUCf8pMblIR8IPCaAeNCg,6279
+agentr-0.1.3.dist-info/METADATA,sha256=YWWFhc2Z9sG48D4zr7lIDJ39JO_pK13RZ5mQO1jiWEY,273
+agentr-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+agentr-0.1.3.dist-info/entry_points.txt,sha256=13fGFeVhgF6_8T-VFiIkNxYO7gDQaUwwTcUNWdvaLQg,42
+agentr-0.1.3.dist-info/RECORD,,

agentr/mcp.py

@@ -1,9 +0,0 @@
-from agentr.server import TestServer
-from agentr.store import MemoryStore
-
-store = MemoryStore()
-
-mcp = TestServer(name="Test Server", description="Test Server", store=store)
-
-if __name__ == "__main__":
-    mcp.run()

agentr-0.1.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-agentr/__init__.py,sha256=LOWhgQayrQV7f5ro4rlBJ_6WevhbWIbjAOHnqP7b_-4,30
-agentr/application.py,sha256=rQ2vomCfZKigdXQLjwCvlTC9_UcnKyux_x9evmQqnjA,1220
-agentr/cli.py,sha256=F16qdCnfgg9UJt7D7VBjZ2-nKvwb7dJ3zezbopNH2YQ,877
-agentr/mcp.py,sha256=kGraScdBgDkCvrzbyg07TTUiIVMXIOF_um7v4g4-4Cs,216
-agentr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentr/server.py,sha256=fweppEwF7L9cRow1zDPHtLYQE-qUdTlICeYUbxHGb2w,990
-agentr/store.py,sha256=u18GL9nDQgkkGm8HFIMz6BiHmy04EDi3vugotbH87ss,689
-agentr/applications/zenquotes/app.py,sha256=4LjYeWdERI8ZMzkajOsDgy9IRTA9plUKem-rW4M03sA,607
-agentr/utils/openapi.py,sha256=yjiPYs-_JsYQ7T3aPh7oimHUCf8pMblIR8IPCaAeNCg,6279
-agentr-0.1.2.dist-info/METADATA,sha256=n6pFbzT-1SjybZX5H81kEjRcpOpfo-HvOkxUMY48PbU,244
-agentr-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-agentr-0.1.2.dist-info/entry_points.txt,sha256=13fGFeVhgF6_8T-VFiIkNxYO7gDQaUwwTcUNWdvaLQg,42
-agentr-0.1.2.dist-info/RECORD,,