kaos-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{kaos_cli-0.6.0 → kaos_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaos-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: CLI for KAOS (K8s Agent Orchestration System)
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{kaos_cli-0.6.0 → kaos_cli-0.7.0}/kaos_cli/__init__.py

@@ -5,4 +5,4 @@ try:
 
     __version__ = version("kaos-cli")
 except Exception:
-    __version__ = "0.5.1.dev0"
+    __version__ = "0.6.1.dev0"

{kaos_cli-0.6.0 → kaos_cli-0.7.0}/kaos_cli/agent/__init__.py

@@ -12,6 +12,7 @@ from kaos_cli.agent.deploy import deploy_agent
 from kaos_cli.agent.invoke import invoke_command
 from kaos_cli.agent.status import status_command
 from kaos_cli.agent.memory import memory_command
+from kaos_cli.agent.tools import tools_command
 from kaos_cli.agent.init import init_command
 from kaos_cli.agent.build import build_command
 from kaos_cli.agent.run import run_command
@@ -46,7 +47,9 @@ def build_agent(
         "agent:agent",
         help="Module:object target (default: agent:agent). No .py extension.",
     ),
-    image: str = typer.Option(..., "--image", "-i", help="Image name with tag (e.g. my-agent:latest)."),
+    image: str = typer.Option(
+        ..., "--image", "-i", help="Image name with tag (e.g. my-agent:latest)."
+    ),
     directory: str = typer.Option(".", "--dir", "-d", help="Source directory."),
     kind_load: bool = typer.Option(
         False, "--kind-load", help="Load image to KIND cluster."
@@ -93,7 +96,9 @@ def run_agent(
     ),
     host: str = typer.Option("0.0.0.0", "--host", help="Bind host."),
     port: int = typer.Option(8000, "--port", "-p", help="Bind port."),
-    reload: bool = typer.Option(False, "--reload", "-r", help="Auto-reload on changes."),
+    reload: bool = typer.Option(
+        False, "--reload", "-r", help="Auto-reload on changes."
+    ),
 ) -> None:
     """Run a Pydantic AI agent server locally."""
     run_command(target=target, host=host, port=port, reload=reload)
@@ -244,13 +249,28 @@ def deploy_agent_cmd(
         None, "--auto-interval", help="Seconds between autonomous iterations."
     ),
     task_max_iterations: int = typer.Option(
-        None, "--task-max-iterations", help="Max iterations for A2A async tasks (0=unlimited)."
+        None,
+        "--task-max-iterations",
+        help="Max iterations for A2A async tasks (0=unlimited).",
     ),
     task_max_runtime: int = typer.Option(
-        None, "--task-max-runtime", help="Max runtime in seconds for A2A async tasks (0=unlimited)."
+        None,
+        "--task-max-runtime",
+        help="Max runtime in seconds for A2A async tasks (0=unlimited).",
     ),
     task_max_tool_calls: int = typer.Option(
-        None, "--task-max-tool-calls", help="Max cumulative tool calls for A2A async tasks (0=unlimited)."
+        None,
+        "--task-max-tool-calls",
+        help="Max cumulative tool calls for A2A async tasks (0=unlimited).",
+    ),
+    memory_store: str = typer.Option(
+        None, "--memory-store", help="MemoryStore reference."
+    ),
+    memory_max_read_scope: str = typer.Option(
+        None, "--memory-max-read-scope", help="Maximum memory read scope."
+    ),
+    memory_tools: str = typer.Option(
+        None, "--memory-tools", help="Memory tools to expose: read, write, or all."
     ),
     dry_run: bool = typer.Option(
         False, "--dry-run", help="Print YAML instead of deploying."
@@ -273,6 +293,17 @@ def deploy_agent_cmd(
         typer.echo("Error: --build requires --image to be set", err=True)
         sys.exit(1)
 
+    if not memory_store and any((memory_max_read_scope, memory_tools)):
+        typer.echo(
+            "Error: memory read scope and tools flags require --memory-store",
+            err=True,
+        )
+        raise typer.Exit(1)
+    if memory_tools not in (None, "read", "write", "all"):
+        raise typer.BadParameter(
+            "must be 'read', 'write', or 'all'", param_hint="--memory-tools"
+        )
+
     # Run build if requested
     if build is not None:
         build_target = build if build else "agent:agent"
@@ -308,6 +339,9 @@ def deploy_agent_cmd(
         task_max_iterations=task_max_iterations,
         task_max_runtime=task_max_runtime,
         task_max_tool_calls=task_max_tool_calls,
+        memory_store=memory_store,
+        memory_max_read_scope=memory_max_read_scope,
+        memory_tools=memory_tools,
         wait=wait,
         wait_timeout=wait_timeout,
         dry_run=dry_run,
@@ -318,7 +352,7 @@ def deploy_agent_cmd(
 def invoke_agent(
     name: str = typer.Argument(..., help="Name of the Agent."),
     message: str = typer.Option(
-        ..., "--message", "-m", help="Message to send to the agent."
+        "Hello", "--message", "-m", help="Message to send to the agent."
     ),
     namespace: str = typer.Option(
         None,
@@ -338,10 +372,26 @@ def invoke_agent(
         "-s",
         help="Stream the response.",
     ),
+    user: str | None = typer.Option(
+        None,
+        "--user",
+        help="Invoke through the gateway with this user's cached token.",
+    ),
+    session: str = typer.Option(
+        None,
+        "--session",
+        help="Conversation session ID.",
+    ),
 ) -> None:
-    """Send a message to an Agent via port-forward."""
+    """Send a message to an Agent directly or through the configured gateway."""
     invoke_command(
-        name=name, namespace=namespace, message=message, port=port, stream=stream
+        name=name,
+        namespace=namespace,
+        message=message,
+        port=port,
+        stream=stream,
+        user=user,
+        session=session,
     )
 
 
@@ -367,7 +417,7 @@ def status_agent(
     ),
 ) -> None:
     """Get agent status and capabilities via agent card.
-    
+
     Examples:
       kaos agent status my-agent
       kaos agent status my-agent --json
@@ -404,7 +454,7 @@ def memory_agent(
     ),
 ) -> None:
     """Get agent memory events.
-    
+
     Examples:
       kaos agent memory my-agent
       kaos agent memory my-agent --json
@@ -417,3 +467,22 @@ def memory_agent(
         port=port,
         output_json=output_json,
     )
+
+
+@app.command(name="tools")
+def tools_agent(
+    name: str = typer.Argument(..., help="Name of the Agent."),
+    namespace: str = typer.Option(
+        None,
+        "--namespace",
+        "-n",
+        help="Namespace of the Agent.",
+    ),
+    output_json: bool = typer.Option(
+        False,
+        "--json",
+        help="Output in JSON format.",
+    ),
+) -> None:
+    """Show the tool definitions presented to the model."""
+    tools_command(name=name, namespace=namespace, output_json=output_json)

{kaos_cli-0.6.0 → kaos_cli-0.7.0}/kaos_cli/agent/deploy.py

@@ -56,6 +56,9 @@ def deploy_agent(
     task_max_iterations: int | None = None,
     task_max_runtime: int | None = None,
     task_max_tool_calls: int | None = None,
+    memory_store: str | None = None,
+    memory_max_read_scope: str | None = None,
+    memory_tools: str | None = None,
     wait: bool = False,
     wait_timeout: int = DEFAULT_WAIT_TIMEOUT,
     dry_run: bool = False,
@@ -68,8 +71,19 @@ def deploy_agent(
     )
 
     # Add config section if description, instructions, telemetry, autonomous, or task budgets provided
-    has_task_budgets = task_max_iterations is not None or task_max_runtime is not None or task_max_tool_calls is not None
-    has_config = description or instructions or otel_endpoint or autonomous or has_task_budgets
+    has_task_budgets = (
+        task_max_iterations is not None
+        or task_max_runtime is not None
+        or task_max_tool_calls is not None
+    )
+    has_config = (
+        description
+        or instructions
+        or otel_endpoint
+        or autonomous
+        or has_task_budgets
+        or memory_store
+    )
     if has_config:
         yaml_content += "  config:\n"
         if description:
@@ -98,6 +112,14 @@ def deploy_agent(
                 yaml_content += f"      maxRuntimeSeconds: {task_max_runtime}\n"
             if task_max_tool_calls is not None:
                 yaml_content += f"      maxToolCalls: {task_max_tool_calls}\n"
+        if memory_store:
+            yaml_content += "    memory:\n"
+            yaml_content += "      type: remote\n"
+            yaml_content += f"      memoryStore: {memory_store}\n"
+            if memory_max_read_scope:
+                yaml_content += f"      maxReadScope: {memory_max_read_scope}\n"
+            if memory_tools:
+                yaml_content += f"      tools: {memory_tools}\n"
 
     # Add MCP servers if provided
     if mcp_servers:

kaos_cli-0.7.0/kaos_cli/agent/invoke.py

@@ -0,0 +1,300 @@
+"""KAOS Agent invoke command."""
+
+import json
+import subprocess
+import sys
+import time
+import signal
+import typer
+
+from kaos_cli.cluster_http import local_service_url
+from kaos_cli.config import load_config, session_token
+from kaos_cli.utils import current_context_namespace
+from kaos_cli.auth.consent import (
+    active_service_alias,
+    reauth_url,
+    service_alias,
+    service_id_from_reauth_url,
+)
+
+
+REASON_TEXT = {
+    "platform_grant_missing": "not granted",
+    "user_grant_required": "user not in a granted group",
+    "access-control unreachable": "access-control unavailable (failing closed)",
+    "access_control_unreachable": "access-control unavailable (failing closed)",
+    "missing token": "no valid identity",
+    "missing_token": "no valid identity",
+}
+
+
+def plain_access_reason(reason: str) -> str:
+    """Translate gateway reason codes into concise user-facing text."""
+    normalized = reason.strip().lower()
+    if normalized in REASON_TEXT:
+        return REASON_TEXT[normalized]
+    if "access-control" in normalized and "unreachable" in normalized:
+        return REASON_TEXT["access-control unreachable"]
+    if "missing" in normalized and "token" in normalized:
+        return REASON_TEXT["missing token"]
+    return reason.replace("_", " ") or "request permitted"
+
+
+def _response_content(response) -> str:
+    try:
+        data = response.json()
+        choices = data.get("choices", [])
+        if choices:
+            return choices[0].get("message", {}).get("content", "")
+        return json.dumps(data, indent=2)
+    except (ValueError, AttributeError):
+        return response.text
+
+
+def _access_control_ready(namespace: str) -> bool:
+    result = subprocess.run(
+        [
+            "kubectl",
+            "get",
+            "deployment/kaos-pdp",
+            "-n",
+            namespace,
+            "-o",
+            "jsonpath={.status.readyReplicas}/{.spec.replicas}",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return False
+    ready, _, desired = result.stdout.partition("/")
+    return bool(ready) and ready == desired and desired != "0"
+
+
+def _invoke_gateway(
+    name: str, namespace: str | None, message: str, user: str | None, session: str | None = None
+) -> None:
+    """Invoke an agent through the configured gateway and print its verdict."""
+    import httpx
+
+    config = load_config()
+    address = config["gateway"].get("address", "").rstrip("/")
+    namespace = namespace or config.get("namespace") or "default"
+    if not address:
+        typer.echo("✗ denied — no gateway address configured")
+        return
+    token = session_token(config, user) if user else None
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    if session:
+        headers["X-Session-ID"] = session
+    try:
+        with local_service_url(address) as local_address:
+            response = httpx.post(
+                f"{local_address}/{namespace}/agent/{name}/v1/chat/completions",
+                headers=headers,
+                json={"messages": [{"role": "user", "content": message}], "stream": False},
+                timeout=120.0,
+            )
+    except (httpx.HTTPError, RuntimeError) as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        return
+    content = _response_content(response)
+    approval_url = reauth_url(response)
+    if approval_url:
+        service_id = service_id_from_reauth_url(approval_url)
+        try:
+            service = service_alias(config, service_id or "")
+        except (httpx.HTTPError, RuntimeError, ValueError):
+            service = "service"
+        typer.echo(
+            f"✗ needs approval — run: kaos auth connect {service} --user {user}"
+        )
+        return
+    if content:
+        typer.echo(content)
+    reason = response.headers.get("x-kaos-access-reason", "")
+    allowed = response.status_code < 400
+    if not reason:
+        if response.status_code in (401, 403) and not token:
+            reason = "missing token"
+        elif response.status_code in (401, 403) and not _access_control_ready(namespace):
+            reason = "access-control unreachable"
+        elif response.status_code in (401, 403) and token:
+            reason = "user_grant_required"
+        elif response.status_code >= 500:
+            reason = "access-control unreachable"
+        else:
+            reason = "request permitted" if allowed else f"HTTP {response.status_code}"
+    if allowed and user:
+        try:
+            service = active_service_alias(config, user, message)
+        except (httpx.HTTPError, RuntimeError, ValueError):
+            service = None
+        if service:
+            typer.echo(f"✓ allowed — acting as {user} on {service}")
+            return
+    mark = "✓ allowed" if allowed else "✗ denied"
+    typer.echo(f"{mark} — {plain_access_reason(reason)}")
+
+
+def _is_autonomous(name: str, namespace: str | None) -> bool:
+    cmd = [
+        "kubectl",
+        "get",
+        "agent",
+        name,
+        "-o",
+        "jsonpath={.spec.config.autonomous.goal}",
+    ]
+    if namespace:
+        cmd.extend(["-n", namespace])
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def invoke_command(
+    name: str,
+    namespace: str | None,
+    message: str,
+    port: int,
+    stream: bool,
+    user: str | None = None,
+    session: str | None = None,
+) -> None:
+    """Send a message to an Agent via port-forward."""
+    import httpx
+
+    config = load_config()
+    direct_namespace = namespace or current_context_namespace()
+    if user or (
+        config["gateway"].get("through_gateway")
+        and not _is_autonomous(name, direct_namespace)
+    ):
+        _invoke_gateway(name, namespace, message, user, session)
+        return
+    namespace = direct_namespace
+
+    # Find the service for this Agent
+    cmd = [
+        "kubectl",
+        "get",
+        "svc",
+        f"agent-{name}",
+        "-o",
+        "jsonpath={.spec.ports[0].port}",
+    ]
+    if namespace:
+        cmd.extend(["-n", namespace])
+    result = subprocess.run(cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        typer.echo(f"Error: Agent '{name}' not found", err=True)
+        sys.exit(1)
+
+    svc_port = result.stdout.strip() or "8000"
+
+    typer.echo(f"Port-forwarding to agent-{name}:{svc_port}...")
+
+    # Start port-forward in background
+    pf_cmd = ["kubectl", "port-forward", f"svc/agent-{name}", f"{port}:{svc_port}"]
+    if namespace:
+        pf_cmd.extend(["-n", namespace])
+    pf_process = subprocess.Popen(
+        pf_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+    )
+
+    def cleanup():
+        pf_process.terminate()
+        pf_process.wait()
+
+    signal.signal(signal.SIGINT, lambda s, f: (cleanup(), sys.exit(0)))
+
+    try:
+        last_error = "port-forward did not become ready"
+        for _ in range(90):
+            if pf_process.poll() is not None:
+                stderr = pf_process.stderr.read().decode() if pf_process.stderr else ""
+                typer.echo(f"Error: Port-forward failed: {stderr}", err=True)
+                sys.exit(1)
+            try:
+                health = httpx.get(f"http://localhost:{port}/health", timeout=2.0)
+                if health.status_code == 200:
+                    break
+                last_error = f"HTTP {health.status_code}"
+            except httpx.HTTPError as exc:
+                last_error = str(exc)
+            time.sleep(1)
+        else:
+            typer.echo(f"Error: Could not connect to Agent: {last_error}", err=True)
+            sys.exit(1)
+
+        typer.echo(f"Sending message: {message}")
+        headers = {"X-Session-ID": session} if session else None
+
+        try:
+            if stream:
+                # Streaming response
+                with httpx.stream(
+                    "POST",
+                    f"http://localhost:{port}/v1/chat/completions",
+                    json={
+                        "messages": [{"role": "user", "content": message}],
+                        "stream": True,
+                    },
+                    headers=headers,
+                    timeout=120.0,
+                ) as response:
+                    typer.echo("\n📤 Response:")
+                    for line in response.iter_lines():
+                        if line.startswith("data: "):
+                            data = line[6:]
+                            if data != "[DONE]":
+                                try:
+                                    chunk = json.loads(data)
+                                    if "choices" in chunk and chunk["choices"]:
+                                        delta = chunk["choices"][0].get("delta", {})
+                                        # Handle reasoning content (displayed before regular content)
+                                        if "content" in delta:
+                                            content = delta["content"]
+                                            if content.startswith("{"):
+                                                content = json.loads(content)
+                                                typer.echo(f'Reasoning step {content["step"]}/{content["max_steps"]} | Action: {content["action"]} | Target: {content["target"]}')
+                                            else:
+                                                typer.echo(content, nl=False)
+                                except json.JSONDecodeError:
+                                    pass
+                    typer.echo("")  # Final newline
+            else:
+                # Non-streaming
+                response = httpx.post(
+                    f"http://localhost:{port}/v1/chat/completions",
+                    json={
+                        "messages": [{"role": "user", "content": message}],
+                        "stream": False,
+                    },
+                    headers=headers,
+                    timeout=120.0,
+                )
+
+                if response.status_code == 200:
+                    result = response.json()
+                    if "choices" in result and result["choices"]:
+                        content = (
+                            result["choices"][0].get("message", {}).get("content", "")
+                        )
+                        typer.echo("\n📤 Response:")
+                        typer.echo(content)
+                    else:
+                        typer.echo(json.dumps(result, indent=2))
+                    typer.echo("✓ allowed — request permitted")
+                else:
+                    typer.echo(
+                        f"Error: HTTP {response.status_code}: {response.text}", err=True
+                    )
+        except httpx.ConnectError:
+            typer.echo("Error: Could not connect to Agent", err=True)
+            sys.exit(1)
+        except Exception as e:
+            typer.echo(f"Error: {e}", err=True)
+    finally:
+        cleanup()

kaos_cli-0.7.0/kaos_cli/agent/memory.py

@@ -0,0 +1,91 @@
+"""KAOS Agent memory command - get agent memory events."""
+
+import json
+import subprocess
+import sys
+import typer
+
+from kaos_cli.utils.port_forward import PortForwardError, port_forward
+
+
+def memory_command(
+    name: str,
+    namespace: str | None,
+    session_id: str | None,
+    port: int,
+    output_json: bool,
+) -> None:
+    """Get agent memory events via port-forward."""
+    import httpx
+
+    # Find the service for this Agent
+    cmd = [
+        "kubectl",
+        "get",
+        "svc",
+        f"agent-{name}",
+        "-o",
+        "jsonpath={.spec.ports[0].port}",
+    ]
+    if namespace:
+        cmd.extend(["-n", namespace])
+    result = subprocess.run(cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        typer.echo(f"Error: Agent '{name}' not found", err=True)
+        sys.exit(1)
+
+    svc_port = result.stdout.strip() or "8000"
+
+    try:
+        with port_forward(
+            f"svc/agent-{name}",
+            int(svc_port),
+            namespace,
+            "/health",
+            local_port=port,
+        ) as base_url:
+            url = f"{base_url}/memory/events"
+            if session_id:
+                url += f"?session_id={session_id}"
+
+            try:
+                response = httpx.get(url, timeout=10.0)
+                response.raise_for_status()
+                memory = response.json()
+            except httpx.HTTPError as exc:
+                typer.echo(f"Error: Failed to get memory events: {exc}", err=True)
+                raise typer.Exit(1)
+
+            if output_json:
+                typer.echo(json.dumps(memory, indent=2))
+            else:
+                events = memory.get("events", [])
+                typer.echo(f"Memory Events: {len(events)} total")
+
+                event_types: dict[str, int] = {}
+                for event in events:
+                    etype = event.get("event_type", "unknown")
+                    event_types[etype] = event_types.get(etype, 0) + 1
+
+                if event_types:
+                    typer.echo("Event Types:")
+                    for etype, count in sorted(event_types.items()):
+                        typer.echo(f"  - {etype}: {count}")
+
+                if events:
+                    typer.echo("\nAll Events:")
+                    for event in events:
+                        etype = event.get("event_type", "unknown")
+                        content = event.get("content", "")
+                        if isinstance(content, dict):
+                            content = json.dumps(content)
+                        typer.echo(f"  [{etype}] {content}")
+    except PortForwardError as exc:
+        typer.echo(f"Error: Port-forward failed: {exc}", err=True)
+        raise typer.Exit(1)
+    except typer.Exit:
+        raise
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)

kaos_cli-0.7.0/kaos_cli/agent/tools.py

@@ -0,0 +1,55 @@
+"""Inspect the tool definitions exposed by a deployed Agent."""
+
+import json
+import subprocess
+
+import httpx
+import typer
+
+from kaos_cli.utils.port_forward import PortForwardError, port_forward
+
+
+def tools_command(name: str, namespace: str | None, output_json: bool) -> None:
+    """Fetch and print an Agent's model-facing tool definitions."""
+    cmd = [
+        "kubectl",
+        "get",
+        "svc",
+        f"agent-{name}",
+        "-o",
+        "jsonpath={.spec.ports[0].port}",
+    ]
+    if namespace:
+        cmd.extend(["-n", namespace])
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        typer.echo(f"Error: Agent '{name}' not found", err=True)
+        raise typer.Exit(1)
+
+    try:
+        with port_forward(
+            f"svc/agent-{name}",
+            int(result.stdout.strip() or "8000"),
+            namespace,
+            "/health",
+        ) as base_url:
+            response = httpx.get(f"{base_url}/tools", timeout=30.0)
+            response.raise_for_status()
+            data = response.json()
+    except (PortForwardError, httpx.HTTPError, json.JSONDecodeError) as exc:
+        typer.echo(f"Error: Could not list Agent tools: {exc}", err=True)
+        raise typer.Exit(1)
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2))
+        return
+
+    tools = data.get("tools", [])
+    typer.echo(f"Tools for {data.get('agent', name)}: {len(tools)}")
+    for tool in tools:
+        typer.echo(f"\n{tool.get('name', '')}")
+        if tool.get("description"):
+            typer.echo(f"  {tool['description']}")
+        schema = json.dumps(tool.get("parameters_json_schema", {}), indent=2)
+        typer.echo("  Schema:")
+        typer.echo("\n".join(f"    {line}" for line in schema.splitlines()))