kagenti-cli 0.7.1__tar.gz

kagenti_cli-0.7.1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.3
+Name: kagenti-cli
+Version: 0.7.1
+Summary: Kagenti ADK CLI
+Author: IBM Corp.
+Requires-Dist: anyio>=4.12.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: requests>=2.32.5
+Requires-Dist: jsonschema>=4.26.0
+Requires-Dist: jsf>=0.11.2
+Requires-Dist: gnureadline>=8.3.3 ; sys_platform != 'win32'
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: inquirerpy>=0.3.4
+Requires-Dist: psutil>=7.2.2
+Requires-Dist: a2a-sdk
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: typer>=0.21.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: kagenti-adk
+Requires-Dist: authlib>=1.6.6
+Requires-Dist: openai>=2.16.0
+Requires-Python: >=3.14, <3.15
+Description-Content-Type: text/markdown
+
+# Agent Stack CLI

kagenti_cli-0.7.1/README.md

@@ -0,0 +1 @@
+# Agent Stack CLI

kagenti_cli-0.7.1/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "kagenti-cli"
+version = "0.7.1"
+description = "Kagenti ADK CLI"
+readme = "README.md"
+authors = [{ name = "IBM Corp." }]
+requires-python = ">=3.14,<3.15"
+dependencies = [
+    "anyio>=4.12.1",
+    "pydantic>=2.12.5",
+    "pydantic-settings>=2.12.0",
+    "requests>=2.32.5",
+    "jsonschema>=4.26.0",
+    "jsf>=0.11.2",
+    'gnureadline>=8.3.3; sys_platform != "win32"',
+    "prompt-toolkit>=3.0.52",
+    "inquirerpy>=0.3.4",
+    "psutil>=7.2.2",
+    "a2a-sdk",                                     # version determined by kagenti-adk
+    "tenacity>=9.1.2",
+    "typer>=0.21.1",
+    "pyyaml>=6.0.3",
+    "kagenti-adk",
+    "authlib>=1.6.6",
+    "openai>=2.16.0",
+]
+
+[dependency-groups]
+dev = ["pyrefly>=0.52.0", "pytest>=9.0.2", "ruff>=0.14.14", "wheel>=0.46.3"]
+
+[tool.uv.sources]
+kagenti-adk = { path = "../adk-py", editable = true }
+
+[project.scripts]
+kagenti-adk = "kagenti_cli:app"
+
+[build-system]
+requires = ["uv_build>=0.10.0,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-include = ["src/kagenti_cli/data"]
+source-exclude = ["**/.DS_Store"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py314"
+lint.select = [
+    "E",     # pycodestyle errors
+    "W",     # pycodestyle warnings
+    "F",     # pyflakes
+    "UP",    # pyupgrade
+    "I",     # isort
+    "B",     # bugbear
+    "N",     # pep8-naming
+    "C4",    # Comprehensions
+    "Q",     # Quotes
+    "SIM",   # Simplify
+    "RUF",   # Ruff
+    "TID",   # tidy-imports
+    "ASYNC", # async
+    # TODO: add "DTZ",   # DatetimeZ
+    # TODO: add "ANN",   # annotations
+]
+lint.ignore = [
+    "E501",  # line lenght (annyoing)
+    "UP013", # update TypedDict to longer syntax -- not necessary
+]
+force-exclude = true
+
+[tool.pyrefly]
+project-includes = ["**/*.py*", "**/*.ipynb"]

kagenti_cli-0.7.1/src/kagenti_cli/__init__.py

@@ -0,0 +1,172 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import typing
+from copy import deepcopy
+
+import kagenti_adk  # noqa: F401 -- imported early due to Pydantic patches
+import typer
+
+import kagenti_cli.commands.agent
+import kagenti_cli.commands.build
+import kagenti_cli.commands.connector
+import kagenti_cli.commands.model
+import kagenti_cli.commands.platform
+import kagenti_cli.commands.self
+import kagenti_cli.commands.server
+
+# import kagenti_cli.commands.user
+from kagenti_cli.async_typer import AsyncTyper
+from kagenti_cli.configuration import Configuration
+
+logging.basicConfig(level=logging.INFO if Configuration().debug else logging.FATAL)
+logging.getLogger("httpx").setLevel(logging.WARNING)  # not sure why this is necessary
+
+
+HELP_TEXT = """\
+Usage: kagenti-adk [OPTIONS] COMMAND [ARGS]...
+
+╭─ Getting Started ──────────────────────────────────────────────────────────╮
+│ ui       Launch the web interface                                          │
+│ list     View all available agents                                         │
+│ info     Show agent details                                                │
+│ run      Run an agent interactively                                        │
+╰────────────────────────────────────────────────────────────────────────────╯
+
+╭─ Agent Management [Admin only] ────────────────────────────────────────────╮
+│ add                               Install an agent                         │
+│ remove                            Uninstall an agent                       │
+│ update                            Update an agent                          │
+│ build                             Build an agent image locally              │
+╰────────────────────────────────────────────────────────────────────────────╯
+
+╭─ Platform & Configuration ─────────────────────────────────────────────────╮
+| connector       Manage connectors to external services                     │
+│ model           Configure 15+ LLM providers [Admin only]                   │
+│ platform        Start, stop, or delete local platform [Local only]         │
+│ server          Connect to remote Kagenti ADK servers                      │
+│ self version    Show Kagenti ADK CLI and Platform version                  │
+│ self upgrade    Upgrade Kagenti ADK CLI and Platform [Local only]          │
+│ self uninstall  Uninstall Kagenti ADK CLI and Platform [Local only]        │
+╰────────────────────────────────────────────────────────────────────────────╯
+
+╭─ Options ──────────────────────────────────────────────────────────────────╮
+│ --version             Show CLI version and exit                            │
+│ --help                Show this help message                               │
+│ --show-completion     Show tab completion script                           │
+│ --install-completion  Enable tab completion for commands                   │
+╰────────────────────────────────────────────────────────────────────────────╯
+"""
+
+
+app = AsyncTyper()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    help: bool = typer.Option(False, "--help", help="Show this message and exit."),
+    version: bool = typer.Option(False, "--version", help="Show CLI version and exit."),
+):
+    if version:
+        asyncio.run(kagenti_cli.commands.self.version())
+        raise typer.Exit()
+    if help or ctx.invoked_subcommand is None:
+        typer.echo(HELP_TEXT)
+        raise typer.Exit()
+
+
+app.add_typer(
+    kagenti_cli.commands.model.app, name="model", no_args_is_help=True, help="Manage model providers. [Admin only]"
+)
+app.add_typer(
+    kagenti_cli.commands.agent.app,
+    name="agent",
+    no_args_is_help=True,
+    help="Manage agents. Some commands are [Admin only].",
+)
+app.add_typer(
+    kagenti_cli.commands.connector.app,
+    name="connector",
+    no_args_is_help=True,
+    help="Manage connectors to external services.",
+)
+app.add_typer(
+    kagenti_cli.commands.platform.app,
+    name="platform",
+    no_args_is_help=True,
+    help="Manage Kagenti ADK platform. [Local only]",
+)
+app.add_typer(
+    kagenti_cli.commands.server.app,
+    name="server",
+    no_args_is_help=True,
+    help="Manage Kagenti ADK servers and authentication.",
+)
+app.add_typer(
+    kagenti_cli.commands.self.app,
+    name="self",
+    no_args_is_help=True,
+    help="Manage Kagenti ADK installation.",
+    hidden=True,
+)
+# TODO: Implement keycloak integration
+# app.add_typer(
+#     kagenti_cli.commands.user.app,
+#     name="user",
+#     no_args_is_help=True,
+#     help="Manage users. [Admin only]",
+# )
+
+
+app.add_typer(kagenti_cli.commands.build.app, name="", no_args_is_help=True, help="Build agent images.")
+
+agent_alias = deepcopy(kagenti_cli.commands.agent.app)
+for cmd in agent_alias.registered_commands:
+    cmd.rich_help_panel = "Agent commands"
+
+app.add_typer(agent_alias, name="", no_args_is_help=True)
+
+
+@app.command("version")
+async def version(
+    verbose: typing.Annotated[bool, typer.Option("-v", "--verbose", help="Show verbose output")] = False,
+):
+    """Print version of the Kagenti ADK CLI."""
+    import kagenti_cli.commands.self
+
+    await kagenti_cli.commands.self.version(verbose=verbose)
+
+
+@app.command("ui")
+async def ui():
+    """Launch the graphical interface."""
+    import webbrowser
+
+    import kagenti_cli.commands.model
+
+    await kagenti_cli.commands.model.ensure_llm_provider()
+
+    config = Configuration()
+    active_server = config.auth_manager.active_server
+
+    if active_server:
+        if "agentstack-api.localtest.me" in active_server:
+            ui_url = active_server.replace("agentstack-api.localtest.me", "agentstack.localtest.me")
+        elif re.search(r"(localhost|127\.0\.0\.1):8333", active_server):
+            ui_url = re.sub(r":8333", ":8334", active_server)
+        else:
+            ui_url = active_server
+    else:
+        ui_url = "http://agentstack.localtest.me:8080"
+
+    webbrowser.open(ui_url)
+
+
+if __name__ == "__main__":
+    app()

kagenti_cli-0.7.1/src/kagenti_cli/__main__.py

@@ -0,0 +1,6 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from kagenti_cli import app
+
+app()

kagenti_cli-0.7.1/src/kagenti_cli/api.py

@@ -0,0 +1,167 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import json
+import logging
+import re
+import urllib
+import urllib.parse
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from datetime import timedelta
+from textwrap import indent
+from typing import Any
+
+import httpx
+import openai
+import pydantic
+from a2a.client import A2AClientError, Client, ClientConfig, ClientFactory
+from a2a.types import AgentCard
+from kagenti_adk.platform.context import ContextToken
+from google.protobuf.json_format import MessageToDict
+from httpx import HTTPStatusError
+from httpx._types import RequestFiles
+
+from kagenti_cli import configuration
+from kagenti_cli.configuration import Configuration
+from kagenti_cli.utils import pick
+
+logger = logging.getLogger(__name__)
+
+config = Configuration()
+
+API_BASE_URL = "api/v1/"
+
+
+async def api_request(
+    method: str,
+    path: str,
+    json: dict | None = None,
+    files: RequestFiles | None = None,
+    params: dict[str, Any] | None = None,
+    use_auth: bool = True,
+) -> dict | None:
+    """Make an API request to the server."""
+    async with configuration.use_platform_client() as client:
+        response = await client.request(
+            method,
+            urllib.parse.urljoin(API_BASE_URL, path),
+            json=json,
+            files=files,
+            params=params,
+            timeout=60,
+            headers=(
+                {"Authorization": f"Bearer {token.access_token}"}
+                if use_auth and (token := await config.auth_manager.load_auth_token())
+                else {}
+            ),
+        )
+        if response.is_error:
+            error = ""
+            try:
+                error = response.json()
+                error = error.get("detail", str(error))
+            except Exception:
+                response.raise_for_status()
+            if response.status_code == 401:
+                message = f'{error}\nexport KAGENTI_ADK_ADMIN_PASSWORD="<PASSWORD>" to set the admin password.'
+                raise HTTPStatusError(message=message, request=response.request, response=response)
+            raise HTTPStatusError(message=error, request=response.request, response=response)
+        if response.content:
+            return response.json()
+
+
+async def api_stream(
+    method: str,
+    path: str,
+    json: dict | None = None,
+    params: dict[str, Any] | None = None,
+    use_auth: bool = True,
+) -> AsyncIterator[dict[str, Any]]:
+    """Make a streaming API request to the server."""
+    import json as jsonlib
+
+    async with (
+        configuration.use_platform_client() as client,
+        client.stream(
+            method,
+            urllib.parse.urljoin(API_BASE_URL, path),
+            json=json,
+            params=params,
+            timeout=timedelta(hours=1).total_seconds(),
+            headers=(
+                {"Authorization": f"Bearer {token.access_token}"}
+                if use_auth and (token := await config.auth_manager.load_auth_token())
+                else {}
+            ),
+        ) as response,
+    ):
+        response: httpx.Response
+        if response.is_error:
+            error = ""
+            try:
+                [error] = [jsonlib.loads(message) async for message in response.aiter_text()]
+                error = error.get("detail", str(error))
+            except Exception:
+                response.raise_for_status()
+            raise HTTPStatusError(message=error, request=response.request, response=response)
+        async for line in response.aiter_lines():
+            if line:
+                yield jsonlib.loads(re.sub("^data:", "", line).strip())
+
+
+async def fetch_server_version() -> str | None:
+    """Fetch server version from OpenAPI schema."""
+
+    class OpenAPIInfo(pydantic.BaseModel):
+        version: str
+
+    class OpenAPISchema(pydantic.BaseModel):
+        info: OpenAPIInfo
+
+    try:
+        response = await api_request("GET", "openapi.json", use_auth=False)
+        if not response:
+            return None
+        schema = OpenAPISchema.model_validate(response)
+        return schema.info.version
+    except Exception as e:
+        logger.warning("Failed to fetch server version: %s", e)
+        return None
+
+
+@asynccontextmanager
+async def a2a_client(agent_card: AgentCard, context_token: ContextToken) -> AsyncIterator[Client]:
+    try:
+        async with httpx.AsyncClient(
+            headers={"Authorization": f"Bearer {context_token.token.get_secret_value()}"},
+            follow_redirects=True,
+            timeout=timedelta(hours=1).total_seconds(),
+        ) as httpx_client:
+            yield ClientFactory(ClientConfig(httpx_client=httpx_client, use_client_preference=True)).create(
+                card=agent_card
+            )
+    except A2AClientError as ex:
+        card_data = json.dumps(
+            pick(MessageToDict(agent_card), {"url", "additional_interfaces", "preferred_transport"}),
+            indent=2,
+        )
+        raise RuntimeError(
+            f"The agent is not reachable, please check that the agent card is configured properly.\n"
+            f"Agent connection info:\n{indent(card_data, prefix='  ')}\n"
+            "Full Error:\n"
+            f"{indent(str(ex), prefix='  ')}"
+        ) from ex
+
+
+@asynccontextmanager
+async def openai_client() -> AsyncIterator[openai.AsyncOpenAI]:
+    async with Configuration().use_platform_client() as platform_client:
+        headers = platform_client.headers.copy()
+        headers.pop("Authorization", None)
+        yield openai.AsyncOpenAI(
+            api_key=platform_client.headers.get("Authorization", "").removeprefix("Bearer ") or "dummy",
+            base_url=urllib.parse.urljoin(str(platform_client.base_url), urllib.parse.urljoin(API_BASE_URL, "openai")),
+            default_headers=headers,
+        )

kagenti_cli-0.7.1/src/kagenti_cli/async_typer.py

@@ -0,0 +1,124 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import inspect
+import re
+import sys
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+import rich.text
+import typer
+from rich.console import RenderResult
+from rich.markdown import Heading, Markdown
+from rich.table import Table
+from typer.core import TyperGroup
+
+from kagenti_cli.configuration import Configuration
+from kagenti_cli.console import console, err_console
+from kagenti_cli.utils import extract_messages, format_error
+
+DEBUG = Configuration().debug
+
+sys.unraisablehook = lambda _: None  # Suppress benign cleanup errors
+
+
+class _LeftAlignedHeading(Heading):
+    def __rich_console__(self, *args, **kwargs) -> RenderResult:
+        for elem in super().__rich_console__(*args, **kwargs):
+            if isinstance(elem, rich.text.Text):
+                elem.justify = "left"
+            yield elem
+
+
+Markdown.elements["heading_open"] = _LeftAlignedHeading
+
+
+@contextmanager
+def create_table(*args, no_wrap: bool = True, **kwargs) -> Iterator[Table]:
+    table = Table(*args, **kwargs, box=None, pad_edge=False, width=console.width, show_header=True)
+    yield table
+    for column in table.columns:
+        column.no_wrap = no_wrap
+        column.overflow = "ellipsis"
+        assert isinstance(column.header, str)
+        column.header = column.header.upper()
+
+    if not table.rows:
+        table._render = lambda *args, **kwargs: [rich.text.Text("<No items found>", style="italic")]
+
+
+class AliasGroup(TyperGroup):
+    """Taken from https://github.com/fastapi/typer/issues/132#issuecomment-2417492805"""
+
+    _CMD_SPLIT_P = re.compile(r" ?[,|] ?")
+
+    def get_command(self, ctx, cmd_name):
+        cmd_name = self._group_cmd_name(cmd_name)
+        return super().get_command(ctx, cmd_name)
+
+    def _group_cmd_name(self, default_name):
+        for cmd in self.commands.values():
+            name = cmd.name
+            if name and default_name in self._CMD_SPLIT_P.split(name):
+                return name
+        return default_name
+
+
+class AsyncTyper(typer.Typer):
+    def __init__(self, *args, **kwargs):
+        kwargs["cls"] = kwargs.get("cls", AliasGroup)
+        super().__init__(*args, **kwargs)
+
+    def command(self, *args, **kwargs):
+        parent_decorator = super().command(*args, **kwargs)
+
+        def decorator(f):
+            @functools.wraps(f)
+            def wrapped_f(*args, **kwargs):
+                if sys.stdout.isatty():
+                    sys.stdout.write("\x1b[>0u")  # disable Kitty Keyboard Protocol (VSCode bug workaround)
+                    sys.stdout.flush()
+                try:
+                    if inspect.iscoroutinefunction(f):
+                        return asyncio.run(f(*args, **kwargs))
+                    else:
+                        return f(*args, **kwargs)
+                except* Exception as ex:
+                    is_permission_error = False
+                    is_connect_error = False
+                    for exc_type, message in extract_messages(ex):
+                        err_console.print(format_error(exc_type, message))
+                        is_connect_error = is_connect_error or exc_type in ["ConnectionError", "ConnectError"]
+                        is_permission_error = is_permission_error or (
+                            exc_type == "HTTPStatusError" and "403" in message
+                        )
+                        err_console.print()
+                    if is_connect_error:
+                        err_console.hint(
+                            "Start the Kagenti ADK platform using: [green]kagenti-adk platform start[/green]. If that does not help, run [green]kagenti-adk platform delete[/green] to clean up, then [green]kagenti-adk platform start[/green] again."
+                        )
+                    elif is_permission_error:
+                        err_console.hint(
+                            "This command requires higher permissions than your account currently has. Contact your administrator for assistance."
+                        )
+                    else:
+                        err_console.hint(
+                            "Are you having consistent problems? If so, try these troubleshooting steps: [green]kagenti-adk platform delete[/green] to remove the platform, and [green]kagenti-adk platform start[/green] to recreate it."
+                        )
+                    if DEBUG:
+                        raise
+                    sys.exit(1)
+                finally:
+                    if sys.stdout.isatty():
+                        sys.stdout.write("\x1b[<u")
+                        sys.stdout.flush()
+
+            parent_decorator(wrapped_f)
+            return f
+
+        return decorator