alloy-runtime-cli 0.2.106__tar.gz → 0.2.108__tar.gz

{alloy_runtime_cli-0.2.106 → alloy_runtime_cli-0.2.108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.106
+Version: 0.2.108
 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.2.3
 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.106
-Requires-Dist: alloy-runtime-types==0.2.106
+Requires-Dist: alloy-runtime-sdk==0.2.108
+Requires-Dist: alloy-runtime-types==0.2.108
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -137,10 +137,25 @@ Rerun a failed, timed-out, cancelled, or approval-waiting hosted execution with:
 alloy pipelines executions rerun <pipeline_id> <execution_id>
 alloy pipelines executions rerun <pipeline_id> <execution_id> --timeout 1800
 alloy pipelines executions get <pipeline_id> <execution_id>
+alloy pipelines executions get <pipeline_id> <execution_id> --watch
+alloy pipelines executions get <pipeline_id> <execution_id> --watch --timeout 600
 ```
 
-`rerun` submits a new hosted attempt asynchronously and returns the queued
-execution state immediately. Poll `get` when you want the terminal result.
+`pipelines executions get --watch` polls the aggregate pipeline live-state endpoint and renders a compact current-state view for active child generations. JSON output emits the raw live-state DTO. Regular `pipelines executions get` remains the durable detail surface for result data, stdout/stderr, failure context, and generation-step diagnostics.
+
+`rerun` submits a new hosted attempt asynchronously and returns the queued execution state immediately. Poll `get` when you want the terminal result.
+
+To regenerate exactly one terminal `ctx.generate_text(step_id="...")` child on the
+next rerun while preserving other completed step cache hits, reset that step first:
+
+```bash
+alloy pipelines executions reset-step <pipeline_id> <execution_id> --step-id draft
+alloy pipelines executions rerun <pipeline_id> <execution_id>
+```
+
+`reset-step` is parent-scoped and server-owned. It preserves the child generation
+row, retires only the exact deterministic key for the requested step, and is
+idempotent if the step was already reset.
 
 ## Configuration
 

{alloy_runtime_cli-0.2.106 → alloy_runtime_cli-0.2.108}/README.md

@@ -115,10 +115,25 @@ Rerun a failed, timed-out, cancelled, or approval-waiting hosted execution with:
 alloy pipelines executions rerun <pipeline_id> <execution_id>
 alloy pipelines executions rerun <pipeline_id> <execution_id> --timeout 1800
 alloy pipelines executions get <pipeline_id> <execution_id>
+alloy pipelines executions get <pipeline_id> <execution_id> --watch
+alloy pipelines executions get <pipeline_id> <execution_id> --watch --timeout 600
 ```
 
-`rerun` submits a new hosted attempt asynchronously and returns the queued
-execution state immediately. Poll `get` when you want the terminal result.
+`pipelines executions get --watch` polls the aggregate pipeline live-state endpoint and renders a compact current-state view for active child generations. JSON output emits the raw live-state DTO. Regular `pipelines executions get` remains the durable detail surface for result data, stdout/stderr, failure context, and generation-step diagnostics.
+
+`rerun` submits a new hosted attempt asynchronously and returns the queued execution state immediately. Poll `get` when you want the terminal result.
+
+To regenerate exactly one terminal `ctx.generate_text(step_id="...")` child on the
+next rerun while preserving other completed step cache hits, reset that step first:
+
+```bash
+alloy pipelines executions reset-step <pipeline_id> <execution_id> --step-id draft
+alloy pipelines executions rerun <pipeline_id> <execution_id>
+```
+
+`reset-step` is parent-scoped and server-owned. It preserves the child generation
+row, retires only the exact deterministic key for the requested step, and is
+idempotent if the step was already reset.
 
 ## Configuration
 

{alloy_runtime_cli-0.2.106 → alloy_runtime_cli-0.2.108}/alloy_runtime_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.106
+Version: 0.2.108
 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.2.3
 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.106
-Requires-Dist: alloy-runtime-types==0.2.106
+Requires-Dist: alloy-runtime-sdk==0.2.108
+Requires-Dist: alloy-runtime-types==0.2.108
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -137,10 +137,25 @@ Rerun a failed, timed-out, cancelled, or approval-waiting hosted execution with:
 alloy pipelines executions rerun <pipeline_id> <execution_id>
 alloy pipelines executions rerun <pipeline_id> <execution_id> --timeout 1800
 alloy pipelines executions get <pipeline_id> <execution_id>
+alloy pipelines executions get <pipeline_id> <execution_id> --watch
+alloy pipelines executions get <pipeline_id> <execution_id> --watch --timeout 600
 ```
 
-`rerun` submits a new hosted attempt asynchronously and returns the queued
-execution state immediately. Poll `get` when you want the terminal result.
+`pipelines executions get --watch` polls the aggregate pipeline live-state endpoint and renders a compact current-state view for active child generations. JSON output emits the raw live-state DTO. Regular `pipelines executions get` remains the durable detail surface for result data, stdout/stderr, failure context, and generation-step diagnostics.
+
+`rerun` submits a new hosted attempt asynchronously and returns the queued execution state immediately. Poll `get` when you want the terminal result.
+
+To regenerate exactly one terminal `ctx.generate_text(step_id="...")` child on the
+next rerun while preserving other completed step cache hits, reset that step first:
+
+```bash
+alloy pipelines executions reset-step <pipeline_id> <execution_id> --step-id draft
+alloy pipelines executions rerun <pipeline_id> <execution_id>
+```
+
+`reset-step` is parent-scoped and server-owned. It preserves the child generation
+row, retires only the exact deterministic key for the requested step, and is
+idempotent if the step was already reset.
 
 ## Configuration
 

{alloy_runtime_cli-0.2.106 → alloy_runtime_cli-0.2.108}/alloy_runtime_cli.egg-info/SOURCES.txt

@@ -237,6 +237,7 @@ cli/commands/pipelines/executions/get_command.py
 cli/commands/pipelines/executions/list_command.py
 cli/commands/pipelines/executions/presenter.py
 cli/commands/pipelines/executions/rerun_command.py
+cli/commands/pipelines/executions/reset_step_command.py
 cli/commands/pipelines/executions/costs/__init__.py
 cli/commands/pipelines/executions/costs/command.py
 cli/commands/pipelines/executions/costs/presenter.py

{alloy_runtime_cli-0.2.106 → alloy_runtime_cli-0.2.108}/alloy_runtime_cli.egg-info/requires.txt

@@ -4,6 +4,6 @@ textual==8.2.3
 genson==1.3.0
 pyperclip==1.11.0
 prompt-toolkit==3.0.52
-alloy-runtime-sdk==0.2.106
-alloy-runtime-types==0.2.106
+alloy-runtime-sdk==0.2.108
+alloy-runtime-types==0.2.108
 trogon==0.6.0

alloy_runtime_cli-0.2.108/cli/commands/pipelines/executions/get_command.py

@@ -0,0 +1,137 @@
+"""Pipeline execution get command implementation."""
+
+import asyncio
+import json
+import time
+from pathlib import Path
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.presenter import (
+    present_execution_detail,
+    watch_pipeline_execution_live,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.output import OutputFormat, OutputService
+
+_POLL_INTERVAL_SECONDS = 3.0
+
+
+def pipelines_executions_get_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+    print_logs: bool = typer.Option(
+        False,
+        "--print-logs",
+        help="Print execution logs",
+    ),
+    result_json_file: str | None = typer.Option(
+        None,
+        "--result-json-file",
+        help="Write execution result to JSON file",
+    ),
+    watch: bool = typer.Option(
+        False,
+        "--watch",
+        help="Poll compact live state until the pipeline execution reaches a terminal state",
+    ),
+    timeout: float | None = typer.Option(
+        None,
+        "--timeout",
+        help="Maximum seconds to wait when using --watch (default: wait indefinitely)",
+    ),
+) -> None:
+    """Get details of a pipeline execution.
+
+    Examples:
+        alloy pipelines executions get 123e4567... 456e7890...
+    """
+    if watch and result_json_file is not None:
+        raise typer.BadParameter("--result-json-file can only be used without --watch")
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    e_uuid = validate_uuid(execution_id, "execution")
+    _execute_get(
+        pipeline_id=p_uuid,
+        execution_id=e_uuid,
+        print_logs=print_logs,
+        result_json_file=result_json_file,
+        watch=watch,
+        timeout=timeout,
+    )
+
+
+@async_command
+async def _execute_get(
+    pipeline_id: UUID,
+    execution_id: UUID,
+    print_logs: bool,
+    result_json_file: str | None,
+    watch: bool,
+    timeout: float | None,
+) -> None:
+    """Execute get execution operation."""
+    async with authenticated_client() as (_config, client):
+        if watch:
+            output = OutputService.get()
+            if output.format == OutputFormat.JSON:
+                start_time = time.monotonic() if timeout is not None else None
+                last_response = await client.get_pipeline_execution_live_state(
+                    pipeline_id, execution_id
+                )
+                while not last_response.is_terminal and not _watch_timed_out(
+                    start_time=start_time,
+                    timeout=timeout,
+                ):
+                    await asyncio.sleep(_POLL_INTERVAL_SECONDS)
+                    last_response = await client.get_pipeline_execution_live_state(
+                        pipeline_id, execution_id
+                    )
+
+                if not last_response.is_terminal:
+                    output.progress(f"Watch timed out after {timeout:.0f}s.")
+                output.raw(last_response)
+                return
+
+            await watch_pipeline_execution_live(
+                client=client,
+                pipeline_id=pipeline_id,
+                execution_id=execution_id,
+                timeout=timeout,
+            )
+            return
+
+        response = await client.get_pipeline_execution(pipeline_id, execution_id)
+
+    if result_json_file is not None:
+        _write_result_json_file(response.execution.result_data, result_json_file)
+
+    present_execution_detail(response, print_logs=print_logs)
+
+
+def _write_result_json_file(
+    result_data: dict[str, object] | None, output_file: str
+) -> None:
+    file_path = Path(output_file).expanduser().resolve()
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_text(json.dumps(result_data, indent=2), encoding="utf-8")
+    OutputService.get().result(
+        action="write",
+        resource="pipeline_execution_result",
+        extra_fields={"Path": str(file_path)},
+    )
+
+
+def _watch_timed_out(start_time: float | None, timeout: float | None) -> bool:
+    if timeout is None:
+        return False
+    if start_time is None:
+        raise RuntimeError("watch timeout requires a start time")
+    return time.monotonic() - start_time >= timeout

alloy_runtime_cli-0.2.108/cli/commands/pipelines/executions/presenter.py

@@ -0,0 +1,326 @@
+"""Presenters for pipeline executions command output."""
+
+import asyncio
+import json
+import time
+from typing import Any, cast
+from uuid import UUID
+
+from pydantic import BaseModel
+from rich.live import Live
+from rich.markup import escape
+from rich.text import Text
+
+from alloy_runtime_types.dtos.executions import ExecutionLiveStateData
+from alloy_runtime_types.dtos.pipeline import (
+    GetPipelineExecutionLiveStateResponse,
+    GetPipelineExecutionResponse,
+    ListPipelineExecutionsResponse,
+    PipelineExecutionDetail,
+    PipelineExecutionLiveGenerationStep,
+    PipelineGenerationStepAttempt,
+)
+
+from cli.infrastructure.formatting.fields import format_datetime
+from cli.infrastructure.output import OutputFormat, OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+_LIVE_POLL_INTERVAL_SECONDS = 3.0
+
+
+def _format_status(status: str) -> str:
+    """Format status with color hints."""
+    return status
+
+
+def _format_duration(duration_ms: int | None) -> Any:
+    """Format duration in human-readable format."""
+    if duration_ms is None:
+        return cast(str, None)
+    if duration_ms < 1000:
+        return f"{duration_ms}ms"
+    return f"{duration_ms / 1000:.1f}s"
+
+
+def _format_optional_datetime(value: Any) -> Any:
+    if value is None:
+        return cast(str, None)
+    return format_datetime(value)
+
+
+def _format_optional_uuid(value: Any) -> Any:
+    if value is None:
+        return cast(str, None)
+    return str(value)
+
+
+def _format_json_block(value: dict[str, object] | None) -> Any:
+    if value is None:
+        return cast(str, None)
+    if isinstance(value, BaseModel):
+        value = value.model_dump(mode="json")
+    return json.dumps(value, indent=2, sort_keys=True, default=str)
+
+
+def _format_live_phase(phase: str | None) -> str:
+    return phase or "—"
+
+
+def _format_preview(text: str | None, *, limit: int = 160) -> str:
+    if not text:
+        return ""
+    return text if len(text) <= limit else text[-limit:]
+
+
+def _format_active_tools(step: PipelineExecutionLiveGenerationStep) -> str:
+    if not step.state.active_tools:
+        return ""
+    return ", ".join(tool.tool_name for tool in step.state.active_tools)
+
+
+def _format_live_preview(state: ExecutionLiveStateData) -> str:
+    preview = _format_preview(state.text_preview) or _format_preview(
+        state.reasoning_preview
+    )
+    return preview.replace("\n", " ")
+
+
+def _format_generation_step_id(step: PipelineExecutionLiveGenerationStep) -> str:
+    if step.step_id:
+        return step.step_id
+    return str(step.generation_execution_id)[:8]
+
+
+def _format_generation_attempt_id(step: PipelineGenerationStepAttempt) -> str:
+    if step.step_id:
+        return step.step_id
+    return str(step.generation_execution_id)[:8]
+
+
+def _format_generation_steps(
+    steps: list[PipelineGenerationStepAttempt],
+) -> Any:
+    if not steps:
+        return cast(str, None)
+    lines: list[str] = []
+    for step in steps:
+        parts = [
+            _format_generation_attempt_id(step),
+            str(step.generation_execution_id),
+            step.status,
+        ]
+        if step.model:
+            parts.append(step.model)
+        if step.retryable is not None:
+            parts.append(f"retryable={step.retryable}")
+        if step.provider_reached is not None:
+            parts.append(f"provider_reached={step.provider_reached}")
+        if step.error_type:
+            parts.append(f"error_type={step.error_type}")
+        lines.append(" | ".join(parts))
+    return "\n".join(lines)
+
+
+def present_executions_list(response: ListPipelineExecutionsResponse) -> None:
+    """Present list of executions with Rich table formatting."""
+    output = OutputService.get()
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="status",
+            header_label="Status",
+            formatter=_format_status,
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="total_duration_ms",
+            header_label="Duration",
+            formatter=_format_duration,
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="queued_at",
+            header_label="Queued",
+            formatter=_format_optional_datetime,
+            compact_line=2,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="external_id",
+            header_label="External ID",
+            formatter=lambda x: x if x else cast(str, None),
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=cast(list[BaseModel], response.executions),
+        title=f"Executions ({response.total})",
+        columns=columns,
+        raw_payload=response,
+    )
+
+
+def _format_tags_from_execution(execution: PipelineExecutionDetail) -> str:
+    """Format tags for display."""
+    if not execution.tags:
+        return "[]"
+    return ", ".join(t.tag_path for t in execution.tags)
+
+
+def present_execution_detail(
+    response: GetPipelineExecutionResponse, *, print_logs: bool = False
+) -> None:
+    """Present execution details with Rich formatting."""
+    output = OutputService.get()
+    execution = response.execution
+
+    fields = [
+        FieldConfig("id", "Execution ID", str),
+        FieldConfig("pipeline_definition_id", "Pipeline ID", _format_optional_uuid),
+        FieldConfig("execution_origin", "Origin"),
+        FieldConfig("status", "Status"),
+        FieldConfig("external_id", "External ID"),
+        FieldConfig("active_attempt_id", "Active Attempt", _format_optional_uuid),
+        FieldConfig("attempt_number", "Attempt"),
+        FieldConfig("epoch", "Epoch"),
+        FieldConfig("queued_at", "Queued At", format_datetime),
+        FieldConfig("started_at", "Started At", _format_optional_datetime),
+        FieldConfig("last_heartbeat_at", "Last Heartbeat", _format_optional_datetime),
+        FieldConfig("completed_at", "Completed At", _format_optional_datetime),
+        FieldConfig("total_duration_ms", "Duration", lambda v: _format_duration(v)),
+        FieldConfig("error_message", "Error"),
+        FieldConfig("tags", "Tags", lambda _: _format_tags_from_execution(execution)),
+    ]
+
+    if execution.failure_context is not None:
+        fields.append(
+            FieldConfig("failure_context", "Failure Context", _format_json_block)
+        )
+
+    if execution.generation_steps:
+        fields.append(
+            FieldConfig(
+                "generation_steps", "Generation Steps", _format_generation_steps
+            )
+        )
+
+    if execution.result_data is not None:
+        fields.append(FieldConfig("result_data", "Result Data", _format_json_block))
+
+    if print_logs and execution.execution_stdout is not None:
+        fields.append(FieldConfig("execution_stdout", "Stdout"))
+
+    if print_logs and execution.execution_stderr is not None:
+        fields.append(FieldConfig("execution_stderr", "Stderr"))
+
+    output.entity(
+        execution,
+        f"Execution: {execution.status}",
+        fields,
+        raw_payload=response,
+    )
+
+
+def present_pipeline_execution_live_state(
+    response: GetPipelineExecutionLiveStateResponse,
+) -> None:
+    output = OutputService.get()
+    if output.format == OutputFormat.JSON:
+        output.raw(response)
+        return
+    output.text(escape(_render_live_state_text(response)))
+
+
+async def watch_pipeline_execution_live(
+    *,
+    client: Any,
+    pipeline_id: UUID,
+    execution_id: UUID,
+    timeout: float | None,
+) -> None:
+    output = OutputService.get()
+    start_time = time.monotonic() if timeout is not None else None
+    response = await client.get_pipeline_execution_live_state(pipeline_id, execution_id)
+
+    with Live(
+        _to_live_state_renderable(response),
+        console=output.console,
+        auto_refresh=False,
+        refresh_per_second=4,
+        vertical_overflow="ellipsis",
+        transient=False,
+        redirect_stdout=False,
+        redirect_stderr=False,
+    ) as live:
+        live.refresh()
+        while not response.is_terminal:
+            if _watch_timed_out(start_time=start_time, timeout=timeout):
+                output.progress(f"Watch timed out after {timeout:.0f}s.")
+                return
+            await asyncio.sleep(_LIVE_POLL_INTERVAL_SECONDS)
+            response = await client.get_pipeline_execution_live_state(
+                pipeline_id, execution_id
+            )
+            live.update(_to_live_state_renderable(response), refresh=True)
+
+
+def _to_live_state_renderable(response: GetPipelineExecutionLiveStateResponse) -> Text:
+    return Text(_render_live_state_text(response))
+
+
+def _render_live_state_text(response: GetPipelineExecutionLiveStateResponse) -> str:
+    lines = [
+        (
+            f"Pipeline execution {response.pipeline_execution_id} · {response.status} "
+            f"· terminal={response.is_terminal}"
+        ),
+        (
+            f"attempt={response.attempt_number or '—'} epoch={response.epoch or '—'} "
+            f"running={response.running_generation_count} "
+            f"tools={response.active_tool_count} live={response.live_state_status}"
+        ),
+        (f"{'Step':<24} {'State':<24} Details"),
+        (f"{'-' * 24} {'-' * 24} {'-' * 48}"),
+    ]
+
+    if not response.generation_steps:
+        lines.append(
+            f"{'—':<24} {f'{response.status} / —':<24} "
+            f"model=— live={response.live_state_status}; "
+            f"activity={_format_optional_datetime(response.latest_live_state_updated_at) or '—'}; "
+            f"tools={response.active_tool_count}; no child generation live rows yet"
+        )
+        return "\n".join(lines)
+
+    for step in response.generation_steps:
+        details = (
+            f"model={step.model or '—'} live={step.live_state_status}; "
+            f"activity={_format_optional_datetime(step.last_activity_at or step.updated_at) or '—'}; "
+            f"tools={_format_active_tools(step) or '—'}; "
+            f"preview={_format_live_preview(step.state) or '—'}"
+        )
+        lines.append(
+            f"{_format_generation_step_id(step):<24} "
+            f"{f'{step.status} / {_format_live_phase(step.phase)}':<24} "
+            f"{details}"
+        )
+    return "\n".join(lines)
+
+
+def _watch_timed_out(start_time: float | None, timeout: float | None) -> bool:
+    if timeout is None:
+        return False
+    if start_time is None:
+        raise RuntimeError("watch timeout requires a start time")
+    return time.monotonic() - start_time >= timeout

alloy_runtime_cli-0.2.108/cli/commands/pipelines/executions/reset_step_command.py

@@ -0,0 +1,79 @@
+"""Pipeline execution reset-step command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from alloy_runtime_types.dtos.pipeline import ResetPipelineExecutionStepResponse
+from cli.commands.flag_utils import validate_uuid
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.output import OutputFormat, OutputService
+
+
+def pipelines_executions_reset_step_command(
+    pipeline_id: str = typer.Argument(..., help="Pipeline UUID"),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Parent pipeline execution UUID whose deterministic step key should be reset",
+    ),
+    step_id: str = typer.Option(
+        ...,
+        "--step-id",
+        help="Pipeline ctx.generate_text step_id to regenerate on the next rerun.",
+    ),
+) -> None:
+    """Reset one pipeline generation step before rerunning the parent execution.
+
+    This is a server-owned override for failed, timed-out, cancelled, or
+    approval-paused parent executions. It preserves the generation row and retires
+    only the deterministic idempotency key for the requested step.
+
+    Example:
+        alloy pipelines executions reset-step 123e4567... 456e7890... --step-id draft
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    e_uuid = validate_uuid(execution_id, "execution")
+    _execute_reset_step(pipeline_id=p_uuid, execution_id=e_uuid, step_id=step_id)
+
+
+@async_command
+async def _execute_reset_step(
+    pipeline_id: UUID,
+    execution_id: UUID,
+    step_id: str,
+) -> None:
+    """Execute reset-step pipeline operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.reset_pipeline_execution_step(
+            pipeline_id,
+            execution_id,
+            step_id=step_id,
+        )
+
+    present_pipeline_execution_reset_step(response)
+
+
+def present_pipeline_execution_reset_step(
+    response: ResetPipelineExecutionStepResponse,
+) -> None:
+    """Present reset-step result."""
+    output = OutputService.get()
+    if output.format == OutputFormat.JSON:
+        output.raw(response)
+        return
+
+    output.result(
+        action="reset-step",
+        resource="pipeline_execution_step",
+        status=response.status,
+        identifier=str(response.generation_execution_id),
+        name=response.step_id,
+        extra_fields={
+            "Pipeline ID": str(response.pipeline_id),
+            "Pipeline Execution ID": str(response.pipeline_execution_id),
+            "Step ID": response.step_id,
+            "Previous External ID": response.previous_external_id,
+            "Already Reset": response.already_reset,
+            "Next Action": response.next_action,
+        },
+    )