alloy-runtime-cli 0.2.49__tar.gz → 0.2.51__tar.gz

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.49
+Version: 0.2.51
 Summary: Alloy Runtime CLI - Command-line interface for Alloy Runtime server
 Keywords: alloy,cli,python,terminal,workflow
 Classifier: Development Status :: 3 - Alpha
@@ -16,8 +16,8 @@ Requires-Dist: textual==8.1.1
 Requires-Dist: genson==1.3.0
 Requires-Dist: pyperclip==1.11.0
 Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: alloy-runtime-sdk==0.2.49
-Requires-Dist: alloy-runtime-types==0.2.49
+Requires-Dist: alloy-runtime-sdk==0.2.51
+Requires-Dist: alloy-runtime-types==0.2.51
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -65,6 +65,15 @@ Use `alloy --format compact` for the existing psql-style human-readable record v
 Use `alloy --format table` for Rich table output in the non-TUI CLI.
 Use `alloy --format json` for automation-friendly machine-readable output.
 
+For live model-execution inspection, use:
+
+```bash
+alloy executions get <execution_id>
+alloy executions get <execution_id> --watch
+```
+
+`alloy executions get` uses a dedicated transcript view for human output: one metadata header followed by full chronological reasoning, tool-call, tool-output, and assistant blocks. `--watch` appends only newly observed activity blocks while the execution is still running.
+
 `alloy ping` is the authenticated connectivity check. It confirms who you are, which host you reached, and which server build answered the request.
 
 The CLI pins `toon-format` from the upstream GitHub source because the PyPI stub release is not usable yet.

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/README.md

@@ -43,6 +43,15 @@ Use `alloy --format compact` for the existing psql-style human-readable record v
 Use `alloy --format table` for Rich table output in the non-TUI CLI.
 Use `alloy --format json` for automation-friendly machine-readable output.
 
+For live model-execution inspection, use:
+
+```bash
+alloy executions get <execution_id>
+alloy executions get <execution_id> --watch
+```
+
+`alloy executions get` uses a dedicated transcript view for human output: one metadata header followed by full chronological reasoning, tool-call, tool-output, and assistant blocks. `--watch` appends only newly observed activity blocks while the execution is still running.
+
 `alloy ping` is the authenticated connectivity check. It confirms who you are, which host you reached, and which server build answered the request.
 
 The CLI pins `toon-format` from the upstream GitHub source because the PyPI stub release is not usable yet.

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/alloy_runtime_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.49
+Version: 0.2.51
 Summary: Alloy Runtime CLI - Command-line interface for Alloy Runtime server
 Keywords: alloy,cli,python,terminal,workflow
 Classifier: Development Status :: 3 - Alpha
@@ -16,8 +16,8 @@ Requires-Dist: textual==8.1.1
 Requires-Dist: genson==1.3.0
 Requires-Dist: pyperclip==1.11.0
 Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: alloy-runtime-sdk==0.2.49
-Requires-Dist: alloy-runtime-types==0.2.49
+Requires-Dist: alloy-runtime-sdk==0.2.51
+Requires-Dist: alloy-runtime-types==0.2.51
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -65,6 +65,15 @@ Use `alloy --format compact` for the existing psql-style human-readable record v
 Use `alloy --format table` for Rich table output in the non-TUI CLI.
 Use `alloy --format json` for automation-friendly machine-readable output.
 
+For live model-execution inspection, use:
+
+```bash
+alloy executions get <execution_id>
+alloy executions get <execution_id> --watch
+```
+
+`alloy executions get` uses a dedicated transcript view for human output: one metadata header followed by full chronological reasoning, tool-call, tool-output, and assistant blocks. `--watch` appends only newly observed activity blocks while the execution is still running.
+
 `alloy ping` is the authenticated connectivity check. It confirms who you are, which host you reached, and which server build answered the request.
 
 The CLI pins `toon-format` from the upstream GitHub source because the PyPI stub release is not usable yet.

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/alloy_runtime_cli.egg-info/SOURCES.txt

@@ -107,6 +107,9 @@ cli/commands/credentials/update/__init__.py
 cli/commands/credentials/update/command.py
 cli/commands/credentials/update/fields.py
 cli/commands/credentials/update/presenter.py
+cli/commands/executions/get/command.py
+cli/commands/executions/get/presenter.py
+cli/commands/executions/get/transcript_renderer.py
 cli/commands/generate/__init__.py
 cli/commands/generate/cancel/__init__.py
 cli/commands/generate/cancel/command.py

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/alloy_runtime_cli.egg-info/requires.txt

@@ -4,6 +4,6 @@ textual==8.1.1
 genson==1.3.0
 pyperclip==1.11.0
 prompt-toolkit==3.0.52
-alloy-runtime-sdk==0.2.49
-alloy-runtime-types==0.2.49
+alloy-runtime-sdk==0.2.51
+alloy-runtime-types==0.2.51
 trogon==0.6.0

alloy_runtime_cli-0.2.51/cli/commands/executions/get/command.py

@@ -0,0 +1,79 @@
+import asyncio
+import time
+from uuid import UUID
+
+import typer
+
+from cli.commands.executions.get.presenter import present_execution
+from cli.commands.flag_utils import validate_uuid
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.output import OutputFormat, OutputService
+
+
+_POLL_INTERVAL_SECONDS = 3.0
+
+
+def executions_get_command(
+    execution_id: str = typer.Argument(..., help="Execution UUID"),
+    watch: bool = typer.Option(
+        False, "--watch", help="Poll until execution reaches a terminal state"
+    ),
+    timeout: float = typer.Option(
+        300.0,
+        "--timeout",
+        help="Maximum seconds to wait when using --watch (default: 300)",
+    ),
+) -> None:
+    _execute_get(
+        execution_id=validate_uuid(execution_id, "execution"),
+        watch=watch,
+        timeout=timeout,
+    )
+
+
+@async_command
+async def _execute_get(
+    execution_id: UUID,
+    watch: bool,
+    timeout: float,
+) -> None:
+    async with authenticated_client() as (_config, client):
+        if not watch:
+            response = await client.get_execution(execution_id)
+            present_execution(response)
+            return
+
+        output = OutputService.get()
+        start_time = time.monotonic()
+        metadata_rendered = False
+        rendered_count = 0
+        output.progress(f"Watching execution {execution_id}...")
+
+        if output.format == OutputFormat.JSON:
+            last_response = await client.get_execution(execution_id)
+            while (
+                not last_response.is_terminal
+                and time.monotonic() - start_time < timeout
+            ):
+                await asyncio.sleep(_POLL_INTERVAL_SECONDS)
+                last_response = await client.get_execution(execution_id)
+
+            if not last_response.is_terminal:
+                output.progress(f"Watch timed out after {timeout:.0f}s.")
+            output.raw(last_response)
+            return
+
+        while True:
+            response = await client.get_execution(execution_id)
+            rendered_count = present_execution(
+                response,
+                include_metadata=not metadata_rendered,
+                start_index=rendered_count,
+            )
+            metadata_rendered = True
+            if response.is_terminal:
+                return
+            if time.monotonic() - start_time >= timeout:
+                output.progress(f"Watch timed out after {timeout:.0f}s.")
+                return
+            await asyncio.sleep(_POLL_INTERVAL_SECONDS)

alloy_runtime_cli-0.2.51/cli/commands/executions/get/presenter.py

@@ -0,0 +1,52 @@
+from alloy_runtime_types.dtos.executions import GetExecutionResponse
+from cli.commands.executions.get.transcript_renderer import (
+    render_activity_blocks,
+    render_appendices,
+    render_execution_header,
+)
+from cli.infrastructure.output import OutputFormat, OutputService
+
+
+def present_execution(
+    response: GetExecutionResponse,
+    *,
+    include_metadata: bool = True,
+    start_index: int = 0,
+) -> int:
+    output = OutputService.get()
+    if output.format == OutputFormat.JSON:
+        output.raw(response)
+        return len(response.activity)
+
+    blocks: list[str] = []
+    if include_metadata:
+        blocks.append(render_execution_header(response))
+
+    activity_blocks = render_activity_blocks(
+        response.activity,
+        start_index=start_index,
+    )
+    if activity_blocks:
+        if include_metadata:
+            blocks.append(
+                "────────────────────────────────────────────────────────────"
+            )
+        blocks.append(activity_blocks)
+    elif include_metadata and response.activity_state == "unavailable":
+        blocks.append("────────────────────────────────────────────────────────────")
+        blocks.append("No live activity is available yet.")
+
+    if include_metadata:
+        appendices = render_appendices(response)
+        if appendices:
+            if blocks:
+                blocks.append(
+                    "────────────────────────────────────────────────────────────"
+                )
+            blocks.append(appendices)
+
+    rendered = "\n\n".join(blocks).rstrip()
+    if rendered:
+        output.text(rendered)
+
+    return len(response.activity)

alloy_runtime_cli-0.2.51/cli/commands/executions/get/transcript_renderer.py

@@ -0,0 +1,132 @@
+import json
+from datetime import datetime
+from typing import Any
+
+from alloy_runtime_types.dtos.executions import (
+    ExecutionActivityItem,
+    GetExecutionResponse,
+)
+
+
+def render_execution_header(response: GetExecutionResponse) -> str:
+    rows: list[tuple[str, str | None]] = [
+        ("Execution", _stringify(response.execution_id)),
+        ("Status", _stringify(response.status)),
+        ("Origin", _stringify(response.origin_label)),
+        ("Purpose", _stringify(response.execution_purpose)),
+        ("Provider", _stringify(response.provider_key)),
+        ("Model", _stringify(response.provider_model_name)),
+        ("Queued", _format_datetime(response.queued_at)),
+        ("Started", _format_datetime(response.started_at)),
+        ("Last Activity", _format_datetime(response.last_activity_at)),
+        ("Completed", _format_datetime(response.completed_at)),
+        ("Activity", _stringify(response.activity_state)),
+    ]
+
+    if response.error_message:
+        rows.append(("Error", _stringify(response.error_message)))
+
+    width = max(len(label) for label, _ in rows)
+    return "\n".join(
+        f"{label.ljust(width)}  {value}" for label, value in rows if value is not None
+    )
+
+
+def render_activity_blocks(
+    activities: list[ExecutionActivityItem], *, start_index: int = 0
+) -> str:
+    rendered: list[str] = []
+    for activity in activities[start_index:]:
+        header = _render_activity_header(activity)
+        body = _render_activity_body(activity)
+        if body:
+            rendered.append(f"{header}\n{body}")
+        else:
+            rendered.append(header)
+    return "\n\n".join(rendered)
+
+
+def render_appendices(response: GetExecutionResponse) -> str:
+    appendices: list[str] = []
+    if response.output_text:
+        appendices.append(f"Final Output\n{response.output_text}")
+    if response.error_message:
+        appendices.append(f"Error\n{response.error_message}")
+    return "\n\n".join(appendices)
+
+
+def _render_activity_header(activity: ExecutionActivityItem) -> str:
+    timestamp = _format_time(activity.timestamp)
+    kind = activity.kind
+    tool_name = _stringify(activity.tool_name)
+
+    if kind == "reasoning":
+        return f"Reasoning [{timestamp}]"
+    if kind == "assistant_text":
+        return f"Assistant [{timestamp}]"
+    if kind == "tool_call":
+        return f"Tool Call · {tool_name or 'tool'} [{timestamp}]"
+    if kind == "tool_started":
+        return f"Tool Started · {tool_name or 'tool'} [{timestamp}]"
+    if kind == "tool_completed":
+        return f"Tool Output · {tool_name or 'tool'} [{timestamp}]"
+    if kind == "tool_failed":
+        return f"Tool Error · {tool_name or 'tool'} [{timestamp}]"
+    return f"Activity [{timestamp}]"
+
+
+def _render_activity_body(activity: ExecutionActivityItem) -> str:
+    content_text = activity.content_text
+    content_structured = activity.content_structured
+
+    if isinstance(content_text, str) and content_text:
+        return content_text
+    if isinstance(content_structured, dict):
+        return _format_structured(content_structured)
+    return ""
+
+
+def _format_structured(payload: dict[str, Any]) -> str:
+    if set(payload.keys()) == {"arguments"} and isinstance(
+        payload.get("arguments"), str
+    ):
+        return _format_argument_string(payload["arguments"])
+
+    if "arguments" in payload and isinstance(payload.get("arguments"), str):
+        enriched = dict(payload)
+        enriched["arguments"] = _maybe_parse_json_string(payload["arguments"])
+        return json.dumps(enriched, indent=2, ensure_ascii=False)
+
+    return json.dumps(payload, indent=2, ensure_ascii=False)
+
+
+def _format_argument_string(value: str) -> str:
+    parsed = _maybe_parse_json_string(value)
+    if isinstance(parsed, dict):
+        return json.dumps(parsed, indent=2, ensure_ascii=False)
+    return value
+
+
+def _maybe_parse_json_string(value: str) -> Any:
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        return value
+
+
+def _format_datetime(value: Any) -> str | None:
+    if not isinstance(value, datetime):
+        return None
+    return value.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+def _format_time(value: Any) -> str:
+    if not isinstance(value, datetime):
+        return "--:--:--"
+    return value.strftime("%H:%M:%S")
+
+
+def _stringify(value: Any) -> str | None:
+    if value is None:
+        return None
+    return str(value)

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/cli/infrastructure/output.py

@@ -113,6 +113,12 @@ class OutputService:
         jsonable = self._to_jsonable(payload)
         self._write_raw_stdout(json.dumps(jsonable, indent=2, default=str))
 
+    def text(self, content: str) -> None:
+        self._write_raw_stdout(content)
+
+    def progress(self, message: str) -> None:
+        print(message, file=sys.stderr)
+
     # Message methods
     def success(self, message: str) -> None:
         """Print a success message.

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/cli/main.py

@@ -8,9 +8,12 @@ import json
 import errno
 import os
 import sys
+from collections.abc import Callable, Iterator, Sequence
+from contextlib import contextmanager
+from enum import Enum
 from importlib import import_module
 from pathlib import Path
-from typing import Any, Optional, Sequence, TextIO, cast
+from typing import Any, Optional, TextIO, cast
 
 import click
 import typer
@@ -127,6 +130,7 @@ from cli.commands.templates.validate.command import templates_validate_command
 from cli.commands.templates.update.command import templates_update_command
 from cli.commands.templates.version.command import templates_version_command
 from cli.commands.content.delete.command import content_delete_command
+from cli.commands.executions.get.command import executions_get_command
 from cli.commands.schemas.update.command import schemas_update_command
 from cli.commands.render.html_to_image.command import render_html_to_image_command
 from cli.commands.knowledge.collections.create.command import (
@@ -218,7 +222,6 @@ from cli.infrastructure.help_json import build_help_json
 from cli.infrastructure.help_markdown import render_help_markdown
 from cli.infrastructure.output import OutputFormat, OutputService
 from alloy_runtime_sdk.logging.config import LogConfig, LogFormat, LogLevel, configure
-from trogon.typer import init_tui
 
 console = Console()
 
@@ -479,6 +482,61 @@ def _launch_tui() -> None:
     run_app(api_url=config.api_url, api_key=config.api_key)
 
 
+def _normalize_trogon_default_value(value: object) -> object:
+    if isinstance(value, Enum):
+        return value.value
+    if isinstance(value, tuple):
+        tuple_values = cast(tuple[object, ...], value)
+        normalized_tuple_items: list[object] = []
+        for item in tuple_values:
+            normalized_tuple_items.append(_normalize_trogon_default_value(item))
+        return tuple(normalized_tuple_items)
+    if isinstance(value, list):
+        list_values = cast(list[object], value)
+        normalized_list_items: list[object] = []
+        for item in list_values:
+            normalized_list_items.append(_normalize_trogon_default_value(item))
+        return normalized_list_items
+    return value
+
+
+@contextmanager
+def patched_trogon_enum_defaults() -> Iterator[None]:
+    from trogon.introspect import MultiValueParamData
+
+    original_process_cli_option = cast(
+        Callable[[object], MultiValueParamData],
+        cast(Any, MultiValueParamData).process_cli_option,
+    )
+
+    def patched_process_cli_option(value: object) -> Any:
+        return original_process_cli_option(_normalize_trogon_default_value(value))
+
+    setattr(
+        MultiValueParamData,
+        "process_cli_option",
+        staticmethod(patched_process_cli_option),
+    )
+    try:
+        yield
+    finally:
+        setattr(
+            MultiValueParamData,
+            "process_cli_option",
+            staticmethod(original_process_cli_option),
+        )
+
+
+def _launch_command_tui() -> None:
+    from trogon import typer as trogon_typer
+
+    with patched_trogon_enum_defaults():
+        trogon_typer.Trogon(
+            typer.main.get_group(app),
+            click_context=click.get_current_context(),
+        ).run()
+
+
 # Register top-level auth commands for convenience
 app.command("login")(login_command)
 app.command("signup")(signup_command)
@@ -745,6 +803,15 @@ tool_configs_app.command("get")(tool_configs_get_command)
 tool_configs_app.command("list")(tool_configs_list_command)
 tool_configs_app.command("update")(tool_configs_update_command)
 
+executions_app = typer.Typer(
+    help="Inspect model executions",
+    no_args_is_help=True,
+)
+
+app.add_typer(executions_app, name="executions")
+
+executions_app.command("get")(executions_get_command)
+
 # Pipelines command group
 pipelines_app = typer.Typer(
     help="Manage and execute pipelines",
@@ -923,7 +990,7 @@ app.add_typer(users_app, name="users")
 users_app.command("create")(users_create_command)
 
 
-init_tui(app)
+app.command("tui", help="Open Textual TUI.")(_launch_command_tui)
 
 
 def main() -> None:

{alloy_runtime_cli-0.2.49 → alloy_runtime_cli-0.2.51}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alloy-runtime-cli"
-version = "0.2.49"
+version = "0.2.51"
 description = "Alloy Runtime CLI - Command-line interface for Alloy Runtime server"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -23,8 +23,8 @@ dependencies = [
   "genson==1.3.0",
   "pyperclip==1.11.0",
   "prompt-toolkit==3.0.52",
-  "alloy-runtime-sdk==0.2.49",
-  "alloy-runtime-types==0.2.49",
+  "alloy-runtime-sdk==0.2.51",
+  "alloy-runtime-types==0.2.51",
   "trogon==0.6.0",
 ]