agentify-toolkit 0.4.3a1__py3-none-any.whl

agentify/__init__.py

@@ -0,0 +1,41 @@
+"""
+Copyright 2026 Backplane Software
+Author: Lewis Sheridan
+License: Apache License, Version 2.0
+Description: Lightweight Python toolkit to build multi-model AI agents.
+"""
+
+from .agentify import Agent
+from .agents import create_agent, create_agents
+from .specs import load_agent_specs
+from .cli_ui import show_agent_menu
+from .web import run_web_ui
+
+__all__ = [
+    "Agent",
+    "load_agent_specs",
+    "create_agent",
+    "create_agents",
+    "show_agent_menu"
+    "run_web_ui"
+]
+
+import os
+
+try:
+    from importlib.metadata import version, PackageNotFoundError
+
+    try:
+        __version__ = version("agentify-toolkit")
+    except PackageNotFoundError:
+        # Fallback when running locally from src/ (not installed)
+        __version__ = "0.0.0-dev"
+except ImportError:
+    # Python <3.8 fallback
+    __version__ = "0.0.0-dev"
+
+# Optional: mark as dev if running in source directory
+if os.path.exists(os.path.join(os.path.dirname(__file__), "..", "pyproject.toml")):
+    # Indicates a local dev environment
+    if not __version__.endswith("-dev"):
+        __version__ += "-dev"

agentify/agentify.py

@@ -0,0 +1,61 @@
+"""
+Copyright 2026 Backplane Software
+Licensed under the Apache License, Version 2.0
+Author: Lewis Sheridan
+Description: Agentify class to build multi-model AI Agents
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from agentify.providers import run_openai, run_anthropic, run_google, run_bedrock, run_x
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+
+@dataclass
+class Agent:
+    name: str
+    description: str
+    provider: str
+    model_id: str
+    role: str
+    version: Optional[str] = field(default="0.0.0")
+
+
+    def get_model(self) -> str:
+        return self.model_id
+    
+    def run(self, user_prompt: str) -> str:
+        match self.provider.lower():
+            case "openai":
+                return run_openai(self.model_id, user_prompt)
+            case "anthropic":
+                return run_anthropic(self.model_id, user_prompt)
+            case "google":
+                return run_google(self.model_id, user_prompt)
+            case "bedrock":
+                return run_bedrock(self.model_id, user_prompt)
+            case "x":
+                return run_x(self.model_id, user_prompt)
+            case _:
+                raise ValueError(f"Unsupported provider: {self.provider}")
+
+    def chat(agent: "Agent"):
+        console = Console()
+        console.print(Panel(
+            f"[bold cyan][/bold cyan]\n[bold cyan]{agent.name.upper()} [/bold cyan] [dim]{agent.version}[/dim]\nRole: {agent.description}\nUsing [yellow]{agent.model_id}[/yellow] by {agent.provider}",
+            border_style="cyan"
+        ))
+        while True:
+            prompt = Prompt.ask("\nEnter your prompt ('/exit' to quit)").strip()
+            if prompt.lower() in ["/exit", "quit"]:
+                console.print("[yellow]Exiting. Goodbye![/yellow]")
+                break
+                
+
+            full_prompt = f"You must assume the role of {agent.role} when responding to this prompt:\n\n{prompt}"
+            with console.status(f"[blue]Sending prompt to model... {agent.name} is thinking...[/blue]", spinner="dots"):
+                response = agent.run(full_prompt)
+            console.print(Panel.fit(response, title="Agent Response", border_style="green"))

agentify/agents.py

@@ -0,0 +1,37 @@
+# Copyright 2026 Backplane Software
+# Licensed under the Apache License, Version 2.0
+
+from agentify import Agent
+import os
+
+def create_agents(specs: list) -> dict[str, Agent]:
+    agents = {}
+    for spec in specs:
+        agent = create_agent(spec)
+        agents[agent.name] = agent
+    return agents
+
+def create_agent(spec: dict, provider: str = None, model: str = None) -> Agent:
+    """
+    Create an Agent from a YAML/spec dictionary, optionally overriding model or provider.
+    """
+    name = spec.get("name")
+    description = spec.get("description")
+    version = spec.get("version")
+    role = spec.get("role")
+
+    model_spec = spec.get("model", {})
+    model_id = model or model_spec.get("id")
+    provider = provider or model_spec.get("provider")
+    api_key_env = model_spec.get("api_key_env")
+
+    if api_key_env:
+        api_key = os.getenv(api_key_env)
+    # if not api_key:
+    #     raise EnvironmentError(
+    #         f"Environment variables '{api_key_env}' is not set"
+    #     )
+    
+    agent = Agent(name=name, provider=provider, model_id=model_id, role=role, description=description, version=version)
+
+    return agent

agentify/cli.py

@@ -0,0 +1,294 @@
+# Copyright 2026 Backplane Software
+# Licensed under the Apache License, Version 2.0
+
+import click
+from pathlib import Path
+import yaml
+import os
+
+from agentify import __version__
+from .specs import load_agent_specs
+from .agents import create_agent, create_agents
+
+from .cli_ui import show_agent_menu
+from .cli_config import set_server, get_server, add_provider, remove_provider, list_providers
+from .runtime_client import list_agents, upload_agent, delete_agent
+
+from .web import run_web_ui
+
+@click.group()
+@click.version_option(version=__version__, prog_name="Agentify")
+def main():
+    """Agentify - Declarative AI Agents and Runtime Management"""
+    pass
+
+# -----------------------------
+# Run local agents (existing logic)
+# -----------------------------
+@main.command()
+@click.argument("path", required=False)
+@click.option("--model", type=str, help="Override the model ID at runtime")
+@click.option("--provider", type=str, help="Override the LLM provider at runtime")
+@click.option("--server", type=str, help="Optional: run on a remote server instead of local")
+@click.option("--web", is_flag=True, help="Run agent with web UI")
+@click.option("--port", type=int, help="Set server port")
+def run(path, provider, model, server, web, port):
+    """
+    Run an agent YAML file or a folder containing agent YAMLs.
+
+    PATH can be:
+      - A single YAML file → runs that agent directly
+      - A folder containing YAML files → presents a menu to select an agent
+    """
+    # Determine target path
+    agent_path = path or "./agents"
+    path = Path(agent_path)
+    click.echo(f"Loading agents from: {path}")
+
+    # If server override is provided, run via runtime API
+    if server:
+        if not path.is_file():
+            raise click.BadParameter("Remote run currently only supports a single YAML file")
+        resp = upload_agent(server, str(path))
+        click.echo(f"Agent uploaded and executed on server {server}: {resp}")
+        return
+
+    # ----- Local / programmatic agent logic -----
+    if path.is_file():
+        # Load YAML File
+        with open(path, "r") as f:
+            spec = yaml.safe_load(f)
+
+        agent = create_agent(spec, provider=provider, model=model)
+
+        if web:
+            run_web_ui(agent, port=port)
+        else:
+            agent.chat()
+
+    elif path.is_dir():
+        # Multi-agent mode
+        specs = load_agent_specs(path)
+        agents = create_agents(specs)
+        agent = show_agent_menu(agents)
+        agent.chat()
+    else:
+        raise click.BadParameter(f"Path does not exist: {path}")
+
+
+# -----------------------------
+# List local agents (interactive)
+# -----------------------------
+@main.command()
+@click.argument("path", required=False)
+def list(path):
+    """
+    List agents in a folder and select one to run (interactive TUI)
+    """
+    agent_path = path or "./agents"
+    path = Path(agent_path)
+    click.echo(f"Listing agents from: {path}")
+
+    if not path.is_dir():
+        raise click.BadParameter(f"Path is not a directory: {path}")
+
+    specs = load_agent_specs(path)
+    if not specs:
+        click.echo("No agent YAML files found.")
+        return
+
+    agents = create_agents(specs)
+    agent = show_agent_menu(agents)
+    agent.chat()
+
+
+# -----------------------------
+# Server configuration
+# -----------------------------
+@main.group()
+def server():
+    """Manage default runtime server configuration"""
+    pass
+
+@server.command("set")
+@click.argument("url")
+def server_set(url):
+    """Set the default runtime server"""
+    set_server(url)
+
+@server.command("show")
+def server_show():
+    """Show the current default runtime server"""
+    url = get_server()
+    if url:
+        click.echo(f"Default server: {url}")
+    else:
+        click.echo("No server configured.")
+
+@main.group()
+def config():
+    """View or manage Agentify configuration"""
+    pass
+
+@config.command("show")
+def config_show():
+    """Show current Agentify configuration"""
+    import json
+    from agentify.cli_config import get_server
+
+    config_data = {
+        "server": get_server()
+    }
+
+    click.echo(json.dumps(config_data, indent=4))
+
+
+# -----------------------------
+# Runtime server commands
+# -----------------------------
+@main.group()
+def runtime():
+    """Manage agents on a remote runtime server"""
+    pass
+
+@runtime.command("list")
+@click.option("--server", default=None, help="Override default server URL")
+def show_server_agents(server):
+    """List agents running on the runtime server"""
+    url = server or get_server()
+    if not url:
+        click.echo("No server configured. Use 'agentify server set <url>'")
+        return
+
+    agents = list_agents(url)
+    click.echo(f"{'NAME':20} {'STATUS':10} {'PROVIDER':10} {'MODEL'}")
+    for a in agents:
+        click.echo(f"{a['name']:20} {a['status']:10} {a['provider']:10} {a['model']}")
+
+@runtime.command("show")
+@click.argument("agent_name")
+@click.option("--server", default=None, help="Override default server URL")
+def runtime_show(agent_name, server):
+    """Show details of a specific agent on the runtime server"""
+    url = server or get_server()
+    if not url:
+        click.echo("No server configured. Use 'agentify server set <url>'")
+        return
+
+    agent = list_agents(url, filter_name=agent_name)  # or implement get_agent_details(agent_name)
+    if not agent:
+        click.echo(f"Agent not found: {agent_name}")
+        return
+
+    # Print detailed info
+    for a in agent:
+        click.echo(f"Name: {a['name']}")
+        click.echo(f"Status: {a['status']}")
+        click.echo(f"Provider: {a['provider']}")
+        click.echo(f"Model: {a['model']}")
+        click.echo(f"Version: {a.get('version', 'N/A')}")
+        click.echo("-" * 40)
+
+@runtime.command("load")
+@click.argument("path")
+@click.option("--server", default=None, help="Override default server URL")
+def upload(path, server):
+    """Upload an agent YAML file to the runtime server"""
+    url = server or get_server()
+    if not url:
+        click.echo("No server configured. Use 'agentify server set <url>'")
+        return
+    resp = upload_agent(url, path)
+    click.echo(f"Uploaded {path} -> {url}: {resp}")
+
+
+@runtime.command("delete")
+@click.argument("agent_name")
+@click.option("--server", default=None, help="Override default server URL")
+def delete(agent_name, server):
+    """Delete an agent from the runtime server"""
+    url = server or get_server()
+    if not url:
+        click.echo("No server configured. Use 'agentify server set <url>'")
+        return
+    resp = delete_agent(url, agent_name)
+    click.echo(f"Deleted {agent_name} from {url}: {resp}")
+
+@main.group()
+def providers():
+    """Add/Remote AI Provider API Keys"""
+    pass
+
+@providers.command("add")
+@click.argument("provider")
+@click.option("--env", "env_var", help="Environment variable name")
+@click.option("--key", help="API key (optional, will prompt if omitted)")
+def providers_add(provider, env_var, key):
+    """Add an AI Provider and API KEY"""
+
+    provider = provider.lower()
+    env_var = env_var or f"{provider.upper()}_API_KEY"
+
+    if not key:
+        key = click.prompt(
+            f"Enter API key for {provider}",
+            hide_input=True,
+        )
+
+    add_provider(provider, env_var)
+
+    click.echo(f"✓ Provider '{provider}' added to local config\n")
+    click.echo("To apply in your current shell, run:\n")
+    click.echo(f"export {env_var}={key}")
+
+@providers.command("list")
+def providers_list():
+    """List configured providers with their current status"""
+
+    providers = list_providers()
+
+    if not providers:
+        click.echo("No providers configured.")
+        return
+
+    # click.echo("Configured providers:\n")
+    # for name, cfg in providers.items():
+    #     click.echo(f"• {name}")
+    #     click.echo(f"  env: {cfg['env']}\n")
+
+    click.echo("Configured providers:\n")
+    for name, cfg in providers.items():
+        env_var = cfg.get("env")
+    
+        # Check if the env var is present in the current shell
+        if env_var in os.environ and os.environ[env_var]:
+            loaded = click.style("READY", fg="green")  # green for ready
+        else:
+            loaded = click.style(
+                f"MISSING - run command: agentify providers add {name}", fg="yellow"
+            )  # yellow for not set
+
+        click.echo(f"• {name}")
+        click.echo(f"  env: {env_var}")
+        click.echo(f"  status: {loaded}\n")
+
+
+
+@providers.command("remove")
+@click.argument("provider")
+def providers_remove(provider):
+    """Remove a configured providers"""
+
+    env_var = remove_provider(provider)
+
+    if not env_var:
+        click.echo(f"Provider not found: {provider}")
+        return
+
+    click.echo(f"✓ Provider '{provider}' removed from config\n")
+    click.echo("To remove from your current shell, run:\n")
+    click.echo(f"unset {env_var}")
+
+
+if __name__ == "__main__":
+    main()

agentify/cli_config.py

@@ -0,0 +1,100 @@
+import json
+import yaml
+from pathlib import Path
+
+AGENTIFY_DIR = Path.home() / ".agentify"
+CONFIG_PATH = Path.home() / ".agentify" / "config.json"
+PROVIDERS_FILE = AGENTIFY_DIR / "providers.yaml"
+
+def load_config():
+    if CONFIG_PATH.exists():
+        return json.loads(CONFIG_PATH.read_text())
+    return {}
+
+def save_config(config: dict):
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(config, indent=2))
+
+def set_server(url: str):
+    config = load_config()
+    config["server_url"] = url
+    save_config(config)
+    print(f"Default server set to {url}")
+
+def get_server(default=None):
+    config = load_config()
+    return config.get("server_url", default)
+
+
+
+
+# -----------------------------
+# Provider config
+# -----------------------------
+def load_providers():
+    """
+    Load provider configuration from disk.
+
+    Returns:
+        dict: provider configuration
+    """
+    if not PROVIDERS_FILE.exists():
+        return {}
+
+    with open(PROVIDERS_FILE, "r") as f:
+        return yaml.safe_load(f) or {}
+
+
+def save_providers(data: dict):
+    """
+    Persist provider configuration to disk.
+    """
+    AGENTIFY_DIR.mkdir(parents=True, exist_ok=True)
+    with open(PROVIDERS_FILE, "w") as f:
+        yaml.safe_dump(data, f)
+
+
+def add_provider(provider: str, env_var: str):
+    """
+    Register a provider and its environment variable.
+    """
+    provider = provider.lower()
+
+    data = load_providers()
+    data.setdefault("providers", {})
+    data["providers"][provider] = {
+        "env": env_var
+    }
+
+    save_providers(data)
+
+
+def remove_provider(provider: str):
+    """
+    Remove a provider from configuration.
+
+    Returns:
+        str | None: env var name if provider existed
+    """
+    provider = provider.lower()
+    data = load_providers()
+    providers = data.get("providers", {})
+
+    if provider not in providers:
+        return None
+
+    env_var = providers[provider]["env"]
+    del providers[provider]
+    save_providers(data)
+    return env_var
+
+
+def list_providers():
+    """
+    Return configured providers.
+
+    Returns:
+        dict
+    """
+    data = load_providers()
+    return data.get("providers", {})

agentify/cli_ui.py

@@ -0,0 +1,44 @@
+# Copyright 2026 Backplane Software
+# Licensed under the Apache License, Version 2.0
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+
+def show_agent_menu(agents: dict) -> "Agent":
+    console = Console()
+
+    table = Table(title="Available Agents", header_style="bold cyan")
+    table.add_column("#", style="yellow", justify="right")
+    table.add_column("AgentName", style="green")
+    table.add_column("Agent Version", style="dim")
+    table.add_column("Agent Role", style="dim")
+    table.add_column("AI Provider", style="dim")
+    table.add_column("LLM Model", style="dim")
+
+    agent_list = list(agents.values())
+
+    for i, agent in enumerate(agent_list, start=1):
+
+
+        table.add_row(
+            str(i),
+            agent.name,
+            agent.version,
+            agent.description,
+            agent.provider,
+            agent.model_id,
+        )
+
+    console.print(table)
+
+    while True:
+        choice = input("Select an agent: ").strip()
+        if choice.isdigit() and 1 <= int(choice) <= len(agent_list):
+            selected_agent = agent_list[int(choice) - 1]
+            return selected_agent
+        elif int(choice) == (len(agent_list) + 1):
+            console.print("Create custom Agent")
+        console.print("[red]Invalid selection[/red]")
+

agentify/providers/__init__.py

@@ -0,0 +1,5 @@
+from .openai import run_openai
+from .anthropic import run_anthropic
+from .google import run_google
+from .bedrock import run_bedrock
+from .x import run_x

agentify/providers/anthropic.py

@@ -0,0 +1,15 @@
+from anthropic import Anthropic
+
+def run_anthropic(model_id: str, user_prompt: str) -> str:
+    client = Anthropic()  
+    message = client.messages.create(
+        model= model_id,
+        max_tokens=1024,
+        messages=[
+            {
+                "role": "user", 
+                "content": user_prompt
+            }
+        ]
+    )
+    return message.content[0].text

agentify/providers/bedrock.py

@@ -0,0 +1,30 @@
+import boto3
+import json
+
+def run_bedrock(model_id: str, user_prompt: str) -> str:
+        client = boto3.client(
+            service_name="bedrock-runtime",
+            region_name="eu-west-1"
+        )
+
+        body = {
+            "anthropic_version": "bedrock-2023-05-31",
+            "max_tokens": 1024,
+            "temperature": 0.2,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": user_prompt
+                }
+            ]
+        }
+
+        response = client.invoke_model(
+            modelId=model_id,
+            body=json.dumps(body),
+            contentType="application/json",
+            accept="application/json"
+        )
+
+        response_body = json.loads(response["body"].read())
+        return response_body["content"][0]["text"]

agentify/providers/google.py

@@ -0,0 +1,10 @@
+from google import genai
+
+def run_google(model_id: str, user_prompt: str) -> str:
+    client = genai.Client()
+    response = client.models.generate_content(
+        model=model_id,
+        contents=user_prompt
+    )
+
+    return response.text

agentify/providers/openai.py

@@ -0,0 +1,11 @@
+ 
+from openai import OpenAI
+
+def run_openai(model_id: str, user_prompt: str) -> str:
+    client = OpenAI()
+
+    response = client.responses.create(
+        model=model_id,
+        input=user_prompt
+    )
+    return response.output_text

agentify/providers/x.py

@@ -0,0 +1,12 @@
+import os
+from xai_sdk import Client
+from xai_sdk.chat import user, system
+
+def run_x(model_id: str, user_prompt: str) -> str:
+    client = Client()
+    chat = client.chat.create(model=model_id)
+    chat.append(system("You are Grok, a highly intelligent, helpful AI assistant."))
+    chat.append(user(user_prompt))
+    response = chat.sample()
+
+    return response.content

agentify/runtime_client.py

@@ -0,0 +1,23 @@
+import requests
+
+def list_agents(server_url):
+    resp = requests.get(f"{server_url}/agents")
+    resp.raise_for_status()
+    return resp.json()
+
+def upload_agent(server_url, yaml_file):
+    files = {'file': open(yaml_file, 'rb')}
+    resp = requests.post(f"{server_url}/agents", files=files)
+    resp.raise_for_status()
+    return resp.json()
+
+def run_agent(server_url, yaml_file):
+    files = {'file': open(yaml_file, 'rb')}
+    resp = requests.post(f"{server_url}/agents/run", files=files)
+    resp.raise_for_status()
+    return resp.json()
+
+def delete_agent(server_url, agent_name):
+    resp = requests.delete(f"{server_url}/agents/{agent_name}")
+    resp.raise_for_status()
+    return resp.json()