agentify-toolkit 0.19.0__tar.gz → 0.22.0__tar.gz

{agentify_toolkit-0.19.0 → agentify_toolkit-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentify_toolkit
-Version: 0.19.0
+Version: 0.22.0
 Summary: Python Toolkit for Declarative AI Agent Development
 Author-email: Lewis Sheridan <lewis@backplane.dev>
 License:                                  Apache License
@@ -115,6 +115,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
+Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.1

{agentify_toolkit-0.19.0 → agentify_toolkit-0.22.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentify_toolkit"
-version = "0.19.0"
+version = "0.22.0"
 description = "Python Toolkit for Declarative AI Agent Development"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,6 +20,7 @@ classifiers = [
 ]
 
 dependencies = [
+  "tiktoken>=0.12.0",
   "pyyaml>=6.0",
   "rich>=13.0",
   "click>=8.1",

{agentify_toolkit-0.19.0 → agentify_toolkit-0.22.0}/src/agentify/__init__.py

@@ -24,5 +24,5 @@ if os.path.exists(os.path.join(os.path.dirname(__file__), "..", "pyproject.toml"
     if not __version__.endswith("-dev"):
         __version__ += "-dev"
 
-from .agent import Agent
+from agentify.sdk.agent import Agent
 __all__ = ["Agent"]

agentify_toolkit-0.22.0/src/agentify/_bin/_delete_cli.py

@@ -0,0 +1,132 @@
+# src/agentify/cli.py
+import click
+import importlib
+from agentify import __version__
+from rich.console import Console
+from rich.panel import Panel
+
+# --- Console & Banner (instant) ---
+console = Console(force_terminal=True)
+agentify_icon = """
+[white]             ██   [/white]
+[white] █████████████████[/white]    Command: [yellow]agentify provider add <provider_name>[/yellow] [green]# e.g. openai, xai, anthropic[/green]
+[white]░██   ░░███   ░░██[/white]    Command: [yellow]agentify agent new[/yellow] [green]# <-- Creates a new Agent[/green]
+[white]░██     ███     ██[/white]    [green]# Run Agent[/green]
+[white]░█████████████████[/white]    Command: [yellow]agentify run agent.yaml[/yellow]
+[white]░███████   ███████[/white]    [green]# Start MCP Server[/green]                
+[white]░█████████████████[/white]    Command: [yellow]agentify mcp start[/yellow]    
+[white]░░░██░░██░░██░░██ [/white]    [green]# Start Agent Runtime → Deploy Agent[/green]
+[white]  ░██ ░██ ░██ ░██ [/white]    Command: [yellow]agentify runtime start[/yellow] [green]→[/green] [yellow]agentify deploy agent.yaml[/yellow]
+[white]  ░░  ░░  ░░  ░░  [/white]
+"""
+
+COMMANDS = {
+    "provider": {"target": "agentify.commands.provider:provider_group", "help": "Add, remove, or list AI providers (OpenAI, Anthropic, etc.)"},
+    "agent": {"target": "agentify.commands.agent:agent_group", "help": "Create, inspect, and manage AI agents"},
+    "run": {"target": "agentify.commands.run:run_command", "help": "Execute an agent from a YAML configuration file"},
+    "serve": {"target": "agentify.commands.serve:serve_command", "help": "Start an HTTP server to run an agent interactively"},
+    "deploy": {"target": "agentify.commands.deploy:deploy_command", "help": "Deploy an agent to a runtime or production environment"},
+    "runtime": {"target": "agentify.commands.runtime:runtime_group", "help": "Launch and manage the agent runtime environment"},
+    "gateway": {"target": "agentify.commands.gateway:gateway_command", "help": "Start the model gateway for routing AI requests"},
+    "tool": {"target": "agentify.commands.tool:tool_group", "help": "Add, remove, or manage tools for agent use"},
+    "mcp": {"target": "agentify.commands.mcp:mcp_group", "help": "Start and control the MCP server and associated services"},
+    "shell": {"target": "agentify.commands.shell:shell_command", "help": "Start Agentify Terminal Shell"},
+}
+
+# --- Lazy leaf command ---
+class LazyCommand(click.Command):
+    def __init__(self, module_path: str, attr_name: str, help_text: str = None):
+        self.module_path = module_path
+        self.attr_name = attr_name
+        super().__init__(name=attr_name, help=help_text)
+        # Allow extra arguments (must be set after __init__)
+        self.allow_extra_args = True
+        self.ignore_unknown_options = True  # Allows things like 'agent.yaml'
+
+    def invoke(self, ctx):
+        # Lazy import the actual command
+        module = importlib.import_module(self.module_path)
+        real_cmd = getattr(module, self.attr_name)
+
+        if not isinstance(real_cmd, click.Command):
+            raise click.ClickException(f"Command {self.attr_name} is not a Click Command")
+
+        # Forward raw CLI args to the real command
+        return real_cmd.main(args=ctx.args, standalone_mode=False)
+
+# --- Lazy group command ---
+class LazyGroupCommand(click.Group):
+    """Lazy-loaded click.Group with subcommands."""
+    def __init__(self, module_path: str, attr_name: str, help_text: str = None):
+        self.module_path = module_path
+        self.attr_name = attr_name
+        super().__init__(name=attr_name, help=help_text)
+
+    def list_commands(self, ctx):
+        module = importlib.import_module(self.module_path)
+        real_group = getattr(module, self.attr_name)
+        return real_group.list_commands(ctx)
+
+    def get_command(self, ctx, name):
+        module = importlib.import_module(self.module_path)
+        real_group = getattr(module, self.attr_name)
+        return real_group.get_command(ctx, name)
+
+# --- Lazy main group ---
+class LazyMainGroup(click.Group):
+    def list_commands(self, ctx):
+        return COMMANDS.keys()
+
+    def get_command(self, ctx, name):
+        if name not in COMMANDS:
+            return None
+        module_path, attr_name = COMMANDS[name]["target"].split(":")
+        help_text = COMMANDS[name].get("help", None)
+
+        # If the attribute name ends with "_group", treat as LazyGroupCommand
+        if attr_name.endswith("_group"):
+            return LazyGroupCommand(module_path, attr_name, help_text)
+        else:
+            return LazyCommand(module_path, attr_name, help_text)
+
+class LazyGroup(click.Group):
+    def list_commands(self, ctx):
+        return sorted(COMMANDS.keys())
+
+    def get_command(self, ctx, name):
+        if name not in COMMANDS:
+            return None
+
+        # Split module path and attribute
+        module_path, attr_name = COMMANDS[name]["target"].split(":")
+        help_text = COMMANDS[name].get("help")
+
+        # Import module lazily
+        module = importlib.import_module(module_path)
+        cmd = getattr(module, attr_name)
+
+        # Attach help if missing
+        if help_text and getattr(cmd, "help", None) is None:
+            cmd.help = help_text
+
+        return cmd
+    
+# --- Main entrypoint ---
+@click.group(cls=LazyMainGroup, invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="Agentify")
+@click.pass_context
+def main(ctx):
+    """Agentify Toolkit CLI"""
+    # Show banner only if no subcommand is invoked
+    if ctx.invoked_subcommand is None:
+        console.print(
+            Panel(
+                agentify_icon,
+                title=f"AGENTIFY TOOLKIT CLI v{__version__}",
+                subtitle="Build, Run and deploy AI Agents declaratively",
+                border_style="white",
+            )
+        )
+    
+        click.echo()  # blank line
+        click.echo(ctx.command.get_help(ctx))

agentify_toolkit-0.22.0/src/agentify/cli/__init__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+__all__ = ["main"]

agentify_toolkit-0.22.0/src/agentify/cli/main.py

@@ -0,0 +1,132 @@
+# src/agentify/cli.py
+import click
+import importlib
+from agentify import __version__
+from rich.console import Console
+from rich.panel import Panel
+
+# --- Console & Banner (instant) ---
+console = Console(force_terminal=True)
+agentify_icon = """
+[white]             ██   [/white]
+[white] █████████████████[/white]    Command: [yellow]agentify provider add <provider_name>[/yellow] [green]# e.g. openai, xai, anthropic[/green]
+[white]░██   ░░███   ░░██[/white]    Command: [yellow]agentify agent new[/yellow] [green]# <-- Creates a new Agent[/green]
+[white]░██     ███     ██[/white]    [green]# Run Agent[/green]
+[white]░█████████████████[/white]    Command: [yellow]agentify run agent.yaml[/yellow]
+[white]░███████   ███████[/white]    [green]# Start MCP Server[/green]                
+[white]░█████████████████[/white]    Command: [yellow]agentify mcp start[/yellow]    
+[white]░░░██░░██░░██░░██ [/white]    [green]# Start Agent Runtime → Deploy Agent[/green]
+[white]  ░██ ░██ ░██ ░██ [/white]    Command: [yellow]agentify runtime start[/yellow] [green]→[/green] [yellow]agentify deploy agent.yaml[/yellow]
+[white]  ░░  ░░  ░░  ░░  [/white]
+"""
+
+COMMANDS = {
+    "provider": {"target": "agentify.commands.provider:provider_group", "help": "Add, remove, or list AI providers (OpenAI, Anthropic, etc.)"},
+    "agent": {"target": "agentify.commands.agent:agent_group", "help": "Create, inspect, and manage AI agents"},
+    "run": {"target": "agentify.commands.run:run_command", "help": "Execute an agent from a YAML configuration file"},
+    "serve": {"target": "agentify.commands.serve:serve_command", "help": "Start an HTTP server to run an agent interactively"},
+    "deploy": {"target": "agentify.commands.deploy:deploy_command", "help": "Deploy an agent to a runtime or production environment"},
+    "runtime": {"target": "agentify.commands.runtime:runtime_group", "help": "Launch and manage the agent runtime environment"},
+    "gateway": {"target": "agentify.commands.gateway:gateway_command", "help": "Start the model gateway for routing AI requests"},
+    "tool": {"target": "agentify.commands.tool:tool_group", "help": "Add, remove, or manage tools for agent use"},
+    "mcp": {"target": "agentify.commands.mcp:mcp_group", "help": "Start and control the MCP server and associated services"},
+    "shell": {"target": "agentify.commands.shell:shell_command", "help": "Start Agentify Terminal Shell"},
+}
+
+# --- Lazy leaf command ---
+class LazyCommand(click.Command):
+    def __init__(self, module_path: str, attr_name: str, help_text: str = None):
+        self.module_path = module_path
+        self.attr_name = attr_name
+        super().__init__(name=attr_name, help=help_text)
+        # Allow extra arguments (must be set after __init__)
+        self.allow_extra_args = True
+        self.ignore_unknown_options = True  # Allows things like 'agent.yaml'
+
+    def invoke(self, ctx):
+        # Lazy import the actual command
+        module = importlib.import_module(self.module_path)
+        real_cmd = getattr(module, self.attr_name)
+
+        if not isinstance(real_cmd, click.Command):
+            raise click.ClickException(f"Command {self.attr_name} is not a Click Command")
+
+        # Forward raw CLI args to the real command
+        return real_cmd.main(args=ctx.args, standalone_mode=False)
+
+# --- Lazy group command ---
+class LazyGroupCommand(click.Group):
+    """Lazy-loaded click.Group with subcommands."""
+    def __init__(self, module_path: str, attr_name: str, help_text: str = None):
+        self.module_path = module_path
+        self.attr_name = attr_name
+        super().__init__(name=attr_name, help=help_text)
+
+    def list_commands(self, ctx):
+        module = importlib.import_module(self.module_path)
+        real_group = getattr(module, self.attr_name)
+        return real_group.list_commands(ctx)
+
+    def get_command(self, ctx, name):
+        module = importlib.import_module(self.module_path)
+        real_group = getattr(module, self.attr_name)
+        return real_group.get_command(ctx, name)
+
+# --- Lazy main group ---
+class LazyMainGroup(click.Group):
+    def list_commands(self, ctx):
+        return COMMANDS.keys()
+
+    def get_command(self, ctx, name):
+        if name not in COMMANDS:
+            return None
+        module_path, attr_name = COMMANDS[name]["target"].split(":")
+        help_text = COMMANDS[name].get("help", None)
+
+        # If the attribute name ends with "_group", treat as LazyGroupCommand
+        if attr_name.endswith("_group"):
+            return LazyGroupCommand(module_path, attr_name, help_text)
+        else:
+            return LazyCommand(module_path, attr_name, help_text)
+
+class LazyGroup(click.Group):
+    def list_commands(self, ctx):
+        return sorted(COMMANDS.keys())
+
+    def get_command(self, ctx, name):
+        if name not in COMMANDS:
+            return None
+
+        # Split module path and attribute
+        module_path, attr_name = COMMANDS[name]["target"].split(":")
+        help_text = COMMANDS[name].get("help")
+
+        # Import module lazily
+        module = importlib.import_module(module_path)
+        cmd = getattr(module, attr_name)
+
+        # Attach help if missing
+        if help_text and getattr(cmd, "help", None) is None:
+            cmd.help = help_text
+
+        return cmd
+    
+# --- Main entrypoint ---
+@click.group(cls=LazyMainGroup, invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="Agentify")
+@click.pass_context
+def main(ctx):
+    """Agentify Toolkit CLI"""
+    # Show banner only if no subcommand is invoked
+    if ctx.invoked_subcommand is None:
+        console.print(
+            Panel(
+                agentify_icon,
+                title=f"AGENTIFY TOOLKIT CLI v{__version__}",
+                subtitle="Build, Run and deploy AI Agents declaratively",
+                border_style="white",
+            )
+        )
+    
+        click.echo()  # blank line
+        click.echo(ctx.command.get_help(ctx))

{agentify_toolkit-0.19.0 → agentify_toolkit-0.22.0}/src/agentify/commands/__init__.py

@@ -6,7 +6,6 @@ from .agent import agent_group
 from .provider import provider_group
 from .deploy import deploy_command
 from .gateway import gateway_command
-from ._mcp import xmcp_group
 from .mcp import mcp_group
 
 __all__ = [
@@ -19,5 +18,5 @@ __all__ = [
     "provider_group",
     "gateway_command",
     "mcp_group",
-    "xmcp_group"
+    "shell_comamnd"
 ]

{agentify_toolkit-0.19.0 → agentify_toolkit-0.22.0}/src/agentify/commands/agent.py

@@ -108,7 +108,7 @@ def list_agents(path):
     from rich.console import Console
     from rich.table import Table
     from rich.theme import Theme
-    from ..specs import load_agent_specs
+    from agentify.sdk.specs import load_agent_specs
 
     console = Console(theme=Theme({"header": "bold cyan", "highlight": "magenta"}))
 

agentify_toolkit-0.22.0/src/agentify/commands/provider.py

@@ -0,0 +1,106 @@
+import click
+from ..providers.rate_card import get_ratecard
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+@click.group("provider")
+def provider_group():
+    """Manage model providers and API keys"""
+    pass
+
+
+@provider_group.command("add")
+@click.argument("provider_name")
+def add_provider(provider_name):
+    """Add/Update model provider API keys in .env"""
+    from ..utils.env_manager import set_provider_key
+    set_provider_key(provider_name)
+
+
+@provider_group.command("list")
+def list_provider():
+    """Lists registered model providers"""
+
+    from ..utils.env_manager import display_providers
+    display_providers()
+
+
+@provider_group.command("remove")
+@click.argument("provider_name")
+def remove_provider(provider_name):
+    """Remove a model provider"""
+
+    from ..utils.env_manager import remove_provider
+    remove_provider(provider_name)
+
+@provider_group.command("validate")
+@click.argument("provider_name")
+def validate_provider(provider_name):
+    """Validate the Provider API key"""
+
+    from ..utils.env_manager import validate_provider
+    # from rich.console import Console
+    # console = Console(force_terminal=True)
+
+    try:
+        with console.status(f"[yellow]Validating {provider_name}[/yellow]", spinner="dots", spinner_style="yellow"):
+            result = validate_provider(provider_name)
+
+        click.secho(f"✓ {provider_name} API KEY validated: {result}", fg="green")
+        # click.secho(f"✓ {provider_name.upper()}_API_KEY validated", fg="green")
+
+    except Exception as e:
+        click.secho(f"✗ Validation failed: {e}", fg="red")
+        raise SystemExit(1)
+
+
+@provider_group.command("ratecard")
+@click.argument("provider_name", required=False)
+def get_provider_rate(provider_name):
+    """Display provider rate card."""
+
+
+    # If provider_name is None → get all
+    ratecard = get_ratecard(provider_name)
+
+    if not ratecard:
+        console.print(f"[red]No rate card found for '{provider_name}'[/red]")
+        return
+
+    table_title = (
+        f"{provider_name.upper()} Rate Card"
+        if provider_name
+        else "All Providers Rate Card"
+    )
+
+    table = Table(title=table_title)
+
+    table.add_column("Provider", style="cyan", no_wrap=True)
+    table.add_column("Model", style="white", no_wrap=True)
+    table.add_column("Input ($/1M)", justify="right", style="green")
+    table.add_column("Output ($/1M)", justify="right", style="magenta")
+
+    # CASE 1: Specific provider (shape = { model: rates })
+    if provider_name:
+        for model, rates in ratecard.items():
+            table.add_row(
+                provider_name,
+                model,
+                f"{rates['input_rate']:.2f}",
+                f"{rates['output_rate']:.2f}",
+            )
+
+    # CASE 2: All providers (shape = { provider: { model: rates } })
+    else:
+        for provider, models in ratecard.items():
+            for model, rates in models.items():
+                table.add_row(
+                    provider,
+                    model,
+                    f"{rates['input_rate']:.2f}",
+                    f"{rates['output_rate']:.2f}",
+                )
+
+    console.print(table)

agentify_toolkit-0.22.0/src/agentify/commands/run.py

@@ -0,0 +1,85 @@
+import click
+from pathlib import Path
+
+@click.command("run")
+@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("--debug", is_flag=True, help="Turn on debugging to see raw prompt")
+@click.option("--toolprompt", is_flag=True, help="Agent prompts for approval before tool invocation")
+@click.option("--showstats", is_flag=True, help="Display Token usage, cost and latency")
+@click.option("--stream", is_flag=True, help="Stream response")
+def run_command(path, model, provider, server, debug, toolprompt, showstats, stream):
+    """Execute an agent from a YAML file or directory"""
+    import yaml
+    import sys
+    from agentify.sdk.agent import create_agent, create_agents
+    from agentify.sdk.specs import load_agent_specs
+
+    agent_path = path or "./agents"
+    path = Path(agent_path)
+    click.echo(f"Loading agents from: {path}")
+
+    if str(path.parent) not in sys.path:
+        sys.path.insert(0, str(path.parent))
+
+    if server:
+        if not path.is_file():
+            raise click.BadParameter("Remote run only supports a single YAML file")
+        click.echo(f"Would upload agent to server {server}")
+        return
+
+    if path.is_file():
+        with open(path, "r") as f:
+            spec = yaml.safe_load(f)
+
+        agent = create_agent(spec, provider=provider, model=model, agent_file=path.resolve())
+        agent.chat(debug=debug, toolprompt=toolprompt, showstats=showstats, stream=stream)
+
+    elif path.is_dir():
+        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}")
+
+from rich.console import Console
+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]")