supyagent 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

supyagent/cli/main.py

@@ -17,6 +17,7 @@ from rich.table import Table
 from typing import Any
 
 from supyagent.core.agent import Agent
+from supyagent.core.config import ConfigManager, load_config
 from supyagent.core.executor import ExecutionRunner
 from supyagent.core.registry import AgentRegistry
 from supyagent.core.session_manager import SessionManager
@@ -26,7 +27,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="0.1.0", prog_name="supyagent")
+@click.version_option(version="0.2.0", prog_name="supyagent")
 def cli():
     """
     Supyagent - LLM agents powered by supypowers.
@@ -175,6 +176,9 @@ def chat(agent_name: str, new_session: bool, session_id: str | None):
     By default, resumes the most recent session. Use --new to start fresh,
     or --session <id> to resume a specific session.
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load agent config
     try:
         config = load_agent_config(agent_name)
@@ -625,6 +629,9 @@ def run(
         echo "text" | supyagent run summarizer
         supyagent run api-caller '{"endpoint": "/users"}' --secrets API_KEY=xxx
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load agent config
     try:
         config = load_agent_config(agent_name)
@@ -742,6 +749,9 @@ def batch(
         supyagent batch summarizer inputs.jsonl --output results.jsonl
         supyagent batch summarizer data.csv --format csv
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load agent config
     try:
         config = load_agent_config(agent_name)
@@ -879,6 +889,9 @@ def plan(task: str, planner: str, new_session: bool):
         supyagent plan "Create a Python library for data validation"
         supyagent plan "Write a blog post about AI" --planner my-planner
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load planner config
     try:
         config = load_agent_config(planner)
@@ -942,5 +955,171 @@ def cleanup():
         console.print(f"[green]✓[/green] Cleaned up {count} instance(s)")
 
 
+# =============================================================================
+# Config Commands
+# =============================================================================
+
+
+@cli.group()
+def config():
+    """Manage API keys and global configuration."""
+    pass
+
+
+@config.command("set")
+@click.argument("key_name", required=False)
+@click.option(
+    "--value",
+    "-v",
+    help="Set value directly (use with caution - visible in shell history)",
+)
+def config_set(key_name: str | None, value: str | None):
+    """
+    Set an API key.
+
+    If KEY_NAME is not provided, shows an interactive menu of common keys.
+
+    \b
+    Examples:
+        supyagent config set                    # Interactive menu
+        supyagent config set OPENAI_API_KEY     # Set specific key
+        supyagent config set MY_KEY -v "value"  # Set with value (not recommended)
+    """
+    config_mgr = ConfigManager()
+
+    if value:
+        if not key_name:
+            console.print("[red]Error:[/red] KEY_NAME required when using --value")
+            sys.exit(1)
+        config_mgr.set(key_name, value)
+        console.print(f"[green]✓[/green] Saved {key_name}")
+    else:
+        config_mgr.set_interactive(key_name)
+
+
+@config.command("list")
+def config_list():
+    """List all configured API keys."""
+    config_mgr = ConfigManager()
+    config_mgr.show_status()
+
+
+@config.command("delete")
+@click.argument("key_name")
+def config_delete(key_name: str):
+    """Delete a stored API key."""
+    config_mgr = ConfigManager()
+
+    if config_mgr.delete(key_name):
+        console.print(f"[green]✓[/green] Deleted {key_name}")
+    else:
+        console.print(f"[yellow]Key not found:[/yellow] {key_name}")
+
+
+@config.command("import")
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option(
+    "--filter",
+    "-f",
+    "key_filter",
+    help="Only import keys matching this prefix (e.g., 'OPENAI')",
+)
+def config_import(file_path: str, key_filter: str | None):
+    """
+    Import API keys from a .env file.
+
+    The file should contain KEY=VALUE pairs, one per line.
+    Lines starting with # are ignored.
+
+    \b
+    Examples:
+        supyagent config import .env
+        supyagent config import secrets.env --filter OPENAI
+    """
+    config_mgr = ConfigManager()
+
+    try:
+        # If filter is specified, we need custom handling
+        if key_filter:
+            from pathlib import Path
+            import re
+
+            path = Path(file_path)
+            pattern = re.compile(r"^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.+)$")
+            imported = 0
+
+            with open(path) as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#"):
+                        continue
+
+                    match = pattern.match(line)
+                    if match:
+                        name, value = match.groups()
+                        if name.startswith(key_filter.upper()):
+                            if (value.startswith('"') and value.endswith('"')) or (
+                                value.startswith("'") and value.endswith("'")
+                            ):
+                                value = value[1:-1]
+                            config_mgr.set(name, value)
+                            console.print(f"  [green]✓[/green] {name}")
+                            imported += 1
+        else:
+            imported = config_mgr.set_from_file(file_path)
+
+        if imported == 0:
+            console.print("[yellow]No keys found in file[/yellow]")
+        else:
+            console.print(f"\n[green]✓[/green] Imported {imported} key(s)")
+
+    except FileNotFoundError:
+        console.print(f"[red]Error:[/red] File not found: {file_path}")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+
+@config.command("export")
+@click.argument("file_path", type=click.Path())
+@click.option("--force", "-f", is_flag=True, help="Overwrite existing file")
+def config_export(file_path: str, force: bool):
+    """
+    Export stored API keys to a .env file.
+
+    \b
+    Example:
+        supyagent config export backup.env
+    """
+    config_mgr = ConfigManager()
+    path = Path(file_path)
+
+    if path.exists() and not force:
+        console.print(f"[red]Error:[/red] File exists: {file_path}")
+        console.print("Use --force to overwrite")
+        sys.exit(1)
+
+    keys = config_mgr._load_keys()
+
+    if not keys:
+        console.print("[yellow]No keys to export[/yellow]")
+        return
+
+    with open(path, "w") as f:
+        f.write("# Supyagent API Keys\n")
+        f.write("# Generated export - keep this file secure!\n\n")
+        for name, value in sorted(keys.items()):
+            f.write(f"{name}={value}\n")
+
+    # Set restrictive permissions
+    try:
+        path.chmod(0o600)
+    except OSError:
+        pass
+
+    console.print(f"[green]✓[/green] Exported {len(keys)} key(s) to {file_path}")
+
+
 if __name__ == "__main__":
     cli()

supyagent/core/__init__.py

@@ -1,6 +1,7 @@
 """Core module for supyagent."""
 
 from supyagent.core.agent import Agent
+from supyagent.core.config import ConfigManager, load_config
 from supyagent.core.context import DelegationContext
 from supyagent.core.credentials import CredentialManager
 from supyagent.core.delegation import DelegationManager
@@ -12,10 +13,12 @@ from supyagent.core.session_manager import SessionManager
 __all__ = [
     "Agent",
     "AgentRegistry",
+    "ConfigManager",
     "CredentialManager",
     "DelegationContext",
     "DelegationManager",
     "ExecutionRunner",
     "LLMClient",
     "SessionManager",
+    "load_config",
 ]

supyagent/core/config.py

@@ -0,0 +1,352 @@
+"""
+Configuration manager for global settings like LLM API keys.
+
+Stores encrypted configuration in ~/.supyagent/config/ that is shared
+across all agents and projects.
+"""
+
+import getpass
+import json
+import os
+import re
+from pathlib import Path
+
+from cryptography.fernet import Fernet, InvalidToken
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.table import Table
+
+console = Console()
+
+# Common LLM provider API key names
+KNOWN_LLM_KEYS = {
+    "OPENAI_API_KEY": "OpenAI (GPT-4, GPT-3.5)",
+    "ANTHROPIC_API_KEY": "Anthropic (Claude)",
+    "GOOGLE_API_KEY": "Google (Gemini)",
+    "AZURE_API_KEY": "Azure OpenAI",
+    "AZURE_API_BASE": "Azure OpenAI endpoint",
+    "COHERE_API_KEY": "Cohere",
+    "HUGGINGFACE_API_KEY": "Hugging Face",
+    "REPLICATE_API_KEY": "Replicate",
+    "TOGETHER_API_KEY": "Together AI",
+    "GROQ_API_KEY": "Groq",
+    "MISTRAL_API_KEY": "Mistral AI",
+    "PERPLEXITY_API_KEY": "Perplexity AI",
+    "DEEPSEEK_API_KEY": "DeepSeek",
+    "FIREWORKS_API_KEY": "Fireworks AI",
+    "OLLAMA_API_BASE": "Ollama (local) base URL",
+}
+
+
+class ConfigManager:
+    """
+    Manages global configuration including LLM API keys.
+
+    Configuration is stored encrypted in ~/.supyagent/config/
+    and automatically loaded into environment variables when
+    agents are run.
+
+    Directory structure:
+        ~/.supyagent/config/.key     # Encryption key
+        ~/.supyagent/config/keys.enc # Encrypted API keys
+    """
+
+    def __init__(self, base_dir: Path | None = None):
+        """
+        Initialize the config manager.
+
+        Args:
+            base_dir: Base directory for config storage.
+                      Defaults to ~/.supyagent/config/
+        """
+        if base_dir is None:
+            base_dir = Path.home() / ".supyagent" / "config"
+
+        self.base_dir = base_dir
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self._fernet = self._get_fernet()
+        self._cache: dict[str, str] | None = None
+
+    def _get_fernet(self) -> Fernet:
+        """Get or create the encryption key."""
+        key_file = self.base_dir / ".key"
+
+        if key_file.exists():
+            key = key_file.read_bytes()
+        else:
+            key = Fernet.generate_key()
+            key_file.write_bytes(key)
+            try:
+                key_file.chmod(0o600)
+            except OSError:
+                pass
+
+        return Fernet(key)
+
+    def _keys_path(self) -> Path:
+        """Get path to the encrypted keys file."""
+        return self.base_dir / "keys.enc"
+
+    def _load_keys(self) -> dict[str, str]:
+        """Load and decrypt stored keys."""
+        if self._cache is not None:
+            return self._cache
+
+        path = self._keys_path()
+        if not path.exists():
+            self._cache = {}
+            return {}
+
+        try:
+            encrypted = path.read_bytes()
+            decrypted = self._fernet.decrypt(encrypted)
+            keys = json.loads(decrypted)
+            self._cache = keys
+            return keys
+        except (InvalidToken, json.JSONDecodeError):
+            self._cache = {}
+            return {}
+
+    def _save_keys(self, keys: dict[str, str]) -> None:
+        """Encrypt and save keys."""
+        encrypted = self._fernet.encrypt(json.dumps(keys).encode())
+        path = self._keys_path()
+        path.write_bytes(encrypted)
+        try:
+            path.chmod(0o600)
+        except OSError:
+            pass
+        self._cache = keys
+
+    def get(self, name: str) -> str | None:
+        """
+        Get a config value.
+
+        Checks environment first, then stored config.
+
+        Args:
+            name: Key name
+
+        Returns:
+            Value or None
+        """
+        # Environment takes precedence
+        if name in os.environ:
+            return os.environ[name]
+
+        keys = self._load_keys()
+        return keys.get(name)
+
+    def set(self, name: str, value: str) -> None:
+        """
+        Set a config value.
+
+        Args:
+            name: Key name
+            value: Key value
+        """
+        keys = self._load_keys()
+        keys[name] = value
+        self._save_keys(keys)
+
+    def delete(self, name: str) -> bool:
+        """
+        Delete a stored key.
+
+        Args:
+            name: Key name
+
+        Returns:
+            True if deleted, False if not found
+        """
+        keys = self._load_keys()
+        if name in keys:
+            del keys[name]
+            self._save_keys(keys)
+            return True
+        return False
+
+    def list_keys(self) -> list[str]:
+        """List all stored key names."""
+        return list(self._load_keys().keys())
+
+    def load_into_environment(self) -> int:
+        """
+        Load all stored keys into environment variables.
+
+        Only sets variables that aren't already in the environment.
+
+        Returns:
+            Number of keys loaded
+        """
+        keys = self._load_keys()
+        loaded = 0
+
+        for name, value in keys.items():
+            if name not in os.environ:
+                os.environ[name] = value
+                loaded += 1
+
+        return loaded
+
+    def set_interactive(self, name: str | None = None) -> bool:
+        """
+        Interactively prompt user to set a key.
+
+        Args:
+            name: Key name, or None to show a menu of common keys
+
+        Returns:
+            True if key was set
+        """
+        if name is None:
+            # Show menu of common keys
+            console.print()
+            console.print("[bold]Common LLM API Keys:[/bold]")
+            console.print()
+
+            items = list(KNOWN_LLM_KEYS.items())
+            for i, (key, desc) in enumerate(items, 1):
+                status = "[green]✓[/green]" if self.get(key) else "[dim]○[/dim]"
+                console.print(f"  {status} [{i}] {key}")
+                console.print(f"      [dim]{desc}[/dim]")
+
+            console.print()
+            console.print(f"  [0] Enter custom key name")
+            console.print()
+
+            choice = input("Select key to set (number or name): ").strip()
+
+            if choice == "0":
+                name = input("Enter key name: ").strip()
+                if not name:
+                    return False
+            elif choice.isdigit():
+                idx = int(choice) - 1
+                if 0 <= idx < len(items):
+                    name = items[idx][0]
+                else:
+                    console.print("[red]Invalid selection[/red]")
+                    return False
+            else:
+                # Treat as key name
+                name = choice.upper()
+
+        # Get the value
+        description = KNOWN_LLM_KEYS.get(name, "API key")
+        console.print()
+        console.print(
+            Panel(
+                f"[bold]{name}[/bold]\n{description}",
+                title="🔑 Set API Key",
+                border_style="blue",
+            )
+        )
+
+        value = getpass.getpass("Enter value (or press Enter to cancel): ")
+
+        if not value:
+            console.print("[dim]Cancelled[/dim]")
+            return False
+
+        self.set(name, value)
+        console.print(f"[green]✓[/green] Saved {name}")
+        return True
+
+    def set_from_file(self, file_path: str | Path) -> int:
+        """
+        Load keys from a .env file.
+
+        File format (one per line):
+            KEY_NAME=value
+            # comments are ignored
+            export KEY_NAME=value  # export prefix is stripped
+
+        Args:
+            file_path: Path to .env file
+
+        Returns:
+            Number of keys imported
+        """
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        imported = 0
+        pattern = re.compile(r"^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.+)$")
+
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+
+                # Skip empty lines and comments
+                if not line or line.startswith("#"):
+                    continue
+
+                match = pattern.match(line)
+                if match:
+                    name, value = match.groups()
+
+                    # Strip quotes if present
+                    if (value.startswith('"') and value.endswith('"')) or \
+                       (value.startswith("'") and value.endswith("'")):
+                        value = value[1:-1]
+
+                    self.set(name, value)
+                    imported += 1
+
+        return imported
+
+    def show_status(self) -> None:
+        """Display current configuration status."""
+        keys = self._load_keys()
+
+        if not keys:
+            console.print("[dim]No API keys configured[/dim]")
+            console.print()
+            console.print("Run [cyan]supyagent config set[/cyan] to add keys")
+            return
+
+        table = Table(title="Configured API Keys")
+        table.add_column("Key", style="cyan")
+        table.add_column("Provider")
+        table.add_column("Status")
+
+        for name in sorted(keys.keys()):
+            provider = KNOWN_LLM_KEYS.get(name, "Custom")
+            # Show if it's overridden by environment
+            if name in os.environ and os.environ[name] != keys[name]:
+                status = "[yellow]env override[/yellow]"
+            else:
+                status = "[green]stored[/green]"
+
+            table.add_row(name, provider, status)
+
+        console.print(table)
+        console.print()
+        console.print(f"[dim]Config location: {self.base_dir}[/dim]")
+
+
+# Global config manager instance
+_config_manager: ConfigManager | None = None
+
+
+def get_config_manager() -> ConfigManager:
+    """Get the global config manager instance."""
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ConfigManager()
+    return _config_manager
+
+
+def load_config() -> int:
+    """
+    Load global config into environment.
+
+    Call this at the start of any agent execution.
+
+    Returns:
+        Number of keys loaded
+    """
+    return get_config_manager().load_into_environment()

{supyagent-0.1.0.dist-info → supyagent-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supyagent
-Version: 0.1.0
+Version: 0.2.0
 Summary: LLM agents powered by supypowers - build AI agents with tool use, multi-agent orchestration, and secure credential management
 Project-URL: Homepage, https://github.com/ergodic-ai/supyagent
 Project-URL: Documentation, https://github.com/ergodic-ai/supyagent#readme
@@ -68,6 +68,9 @@ uv pip install supyagent
 ## Quick Start
 
 ```bash
+# Set up your API key (stored securely)
+supyagent config set ANTHROPIC_API_KEY
+
 # Create your first agent
 supyagent new myagent
 
@@ -133,39 +136,40 @@ supyagent plan "Build a Python library for data validation"
 # The planner will delegate to specialist agents (coder, writer, researcher)
 ```
 
-## Agent Configuration
+## Configuration
 
-Agents are defined in YAML files in the `agents/` directory:
+### Setting Up API Keys
 
-```yaml
-name: researcher
-description: An AI research assistant
-type: interactive  # or "execution"
+Supyagent securely stores your LLM API keys so you don't need to export them every time:
 
-model:
-  provider: anthropic/claude-3-5-sonnet-20241022
-  temperature: 0.7
-  max_tokens: 4096
+```bash
+# Interactive setup (recommended)
+supyagent config set
+# Shows a menu of common providers to choose from
 
-system_prompt: |
-  You are a helpful research assistant...
+# Set a specific key
+supyagent config set ANTHROPIC_API_KEY
+supyagent config set OPENAI_API_KEY
 
-tools:
-  allow:
-    - "*"           # Allow all tools
-    # or be specific:
-    # - "web:*"     # All functions in web.py
-    # - "math:calc" # Specific function
-  deny:
-    - "dangerous:*" # Block specific tools
+# Import from a .env file
+supyagent config import .env
 
-# For multi-agent support
-delegates:
-  - coder
-  - writer
+# Import only specific keys
+supyagent config import .env --filter OPENAI
+
+# List configured keys
+supyagent config list
+
+# Export keys to backup
+supyagent config export backup.env
+
+# Delete a key
+supyagent config delete OPENAI_API_KEY
 ```
 
-### LLM Providers
+Keys are encrypted and stored in `~/.supyagent/config/`. They're automatically loaded when running any agent command.
+
+### Supported Providers
 
 Supyagent uses LiteLLM, supporting 100+ providers:
 
@@ -187,11 +191,36 @@ model:
   provider: gemini/gemini-pro
 ```
 
-Set API keys as environment variables:
+## Agent Configuration
 
-```bash
-export OPENAI_API_KEY=sk-...
-export ANTHROPIC_API_KEY=sk-ant-...
+Agents are defined in YAML files in the `agents/` directory:
+
+```yaml
+name: researcher
+description: An AI research assistant
+type: interactive  # or "execution"
+
+model:
+  provider: anthropic/claude-3-5-sonnet-20241022
+  temperature: 0.7
+  max_tokens: 4096
+
+system_prompt: |
+  You are a helpful research assistant...
+
+tools:
+  allow:
+    - "*"           # Allow all tools
+    # or be specific:
+    # - "web:*"     # All functions in web.py
+    # - "math:calc" # Specific function
+  deny:
+    - "dangerous:*" # Block specific tools
+
+# For multi-agent support
+delegates:
+  - coder
+  - writer
 ```
 
 ## CLI Reference
@@ -223,6 +252,16 @@ export ANTHROPIC_API_KEY=sk-ant-...
 | `supyagent agents` | List active agent instances |
 | `supyagent cleanup` | Remove completed instances |
 
+### Config Commands
+
+| Command | Description |
+|---------|-------------|
+| `supyagent config set [KEY]` | Set an API key (interactive menu if no key specified) |
+| `supyagent config list` | List all configured keys |
+| `supyagent config import <file>` | Import keys from .env file |
+| `supyagent config export <file>` | Export keys to .env file |
+| `supyagent config delete <key>` | Delete a stored key |
+
 ### In-Chat Commands
 
 While chatting, use these commands:

{supyagent-0.1.0.dist-info → supyagent-0.2.0.dist-info}/RECORD

@@ -1,9 +1,10 @@
 supyagent/__init__.py,sha256=JrrQbk1bmDhUb2qOqxqDGBq1V-oArwVS4f5f9Qu-VcM,77
 supyagent/__main__.py,sha256=szUvsccEIA428c2_5J_X1qzq4L44qLvDvHfuRPYoy7c,121
 supyagent/cli/__init__.py,sha256=7jb5kxHtzce4rNKd9zrAiATp3Zxj7UQvtpQsyA97BTc,32
-supyagent/cli/main.py,sha256=5oM_IZ85C3gyW_ypPmFi3x-khkgd7tZrbowW_kJ_JhY,31028
-supyagent/core/__init__.py,sha256=5GOA6Ca5UBWG_d6lhfZxYdKdDjnKE4UdVooe0lUDpe0,626
+supyagent/cli/main.py,sha256=xV34tTDORoFnp-MU_l0e_RP675bWeUdh3ohVB9uVsBg,36328
+supyagent/core/__init__.py,sha256=7MI6K2-OR_Fg0wcMziC4u3gNa0YxWmzJXO0RtOCevUg,727
 supyagent/core/agent.py,sha256=mkiV6CnK6Vk0Wg-DiAMm29wAViMa52-1Yb33Y5-FvQY,12655
+supyagent/core/config.py,sha256=kuTpuxy-qr-fhou7rJ-JLF82cdzdHQTu46kCZccSw1Y,10041
 supyagent/core/context.py,sha256=ywen6IjWxcudxtipeqA_PHpZKdjK52eqOb9xy7QKnTM,4565
 supyagent/core/credentials.py,sha256=35JBrzMOEDzHnn3XuyGmRjXVdSICL3tups3BLO_NCXQ,7600
 supyagent/core/delegation.py,sha256=B6OYlLjkZaRTPMQsK9nIGeXVO9JeC7RDpxXsOk652xs,9391
@@ -17,8 +18,8 @@ supyagent/models/agent_config.py,sha256=sQ7S7zExoFs0g-IMgACsGH2SMiDRjJTnCVZwhN6D
 supyagent/models/session.py,sha256=_Dwuija_Uvt_KzcNp82ja8qP5ltNHHz43Llug1vq1ic,1136
 supyagent/utils/__init__.py,sha256=l4HdE3n8axphMInBex1J1dB_O1MjzbZz6ot1l8Syf0g,39
 supyagent/utils/paths.py,sha256=Xum9kX_UjRvmshifSq423QsAKynpnyAVfpWuFjlsdDQ,692
-supyagent-0.1.0.dist-info/METADATA,sha256=ooG14oWAy-YelwL-QC3DDZL8aFhDzM6Gs9mdjFW3xw4,8430
-supyagent-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-supyagent-0.1.0.dist-info/entry_points.txt,sha256=7dFXWtRewhLfA5XUckV7Yu1E5_c6c9lq8Gz-7BFs6TM,53
-supyagent-0.1.0.dist-info/licenses/LICENSE,sha256=35fw1cvTM-IhiR3xaUohbiFBc2OBNRjI5z1b1cF7vZI,1067
-supyagent-0.1.0.dist-info/RECORD,,
+supyagent-0.2.0.dist-info/METADATA,sha256=lnle2YIGJXssPNm8jllCvhA_202_j3DL9CUNFiRGHO0,9562
+supyagent-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+supyagent-0.2.0.dist-info/entry_points.txt,sha256=7dFXWtRewhLfA5XUckV7Yu1E5_c6c9lq8Gz-7BFs6TM,53
+supyagent-0.2.0.dist-info/licenses/LICENSE,sha256=35fw1cvTM-IhiR3xaUohbiFBc2OBNRjI5z1b1cF7vZI,1067
+supyagent-0.2.0.dist-info/RECORD,,