agentcore-cli 0.31.1__py3-none-any.whl

agentcore/operations/insights/insights_storage.py

@@ -0,0 +1,67 @@
+"""Legacy insights run storage (port of operations/insights/insights-storage.ts): ``<configRoot>/.cli/insights/``.
+
+Unused by upstream commands (the job engine stores insights under ``.cli/jobs/insights``); kept for parity.
+"""
+
+import json
+import os
+from typing import Any
+
+from agentcore.lib import find_config_root
+from agentcore.lib.utils.json_format import to_json_string
+from agentcore.operations.jobs.shared.storage import drop_undefined
+
+INSIGHTS_DIR = "insights"
+
+
+def _insights_dir() -> str:
+    config_root = find_config_root()
+    if not config_root:
+        raise Exception("No agentcore project found. Run `agentcore create` first.")
+    return os.path.join(config_root, ".cli", INSIGHTS_DIR)
+
+
+def _write(path: str, record: dict[str, Any]) -> None:
+    with open(path, "w", encoding="utf-8", newline="") as fh:
+        fh.write(to_json_string(drop_undefined(record), 2))
+
+
+def save_insights_run(record: dict[str, Any]) -> str:
+    directory = _insights_dir()
+    os.makedirs(directory, exist_ok=True)
+    path = os.path.join(directory, f"{record['batchEvaluationId']}.json")
+    _write(path, record)
+    return path
+
+
+def load_insights_run(batch_evaluation_id: str) -> dict[str, Any]:
+    name = batch_evaluation_id if batch_evaluation_id.endswith(".json") else f"{batch_evaluation_id}.json"
+    path = os.path.join(_insights_dir(), name)
+    if not os.path.exists(path):
+        raise Exception(f'Insights run "{batch_evaluation_id}" not found at {path}')
+    with open(path, encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def list_insights_runs() -> list[dict[str, Any]]:
+    directory = _insights_dir()
+    if not os.path.isdir(directory):
+        return []
+    out = []
+    for f in sorted((f for f in os.listdir(directory) if f.endswith(".json")), reverse=True):
+        with open(os.path.join(directory, f), encoding="utf-8") as fh:
+            out.append(json.load(fh))
+    return out
+
+
+def delete_local_insights_run(batch_evaluation_id: str) -> bool:
+    path = os.path.join(_insights_dir(), f"{batch_evaluation_id}.json")
+    if not os.path.exists(path):
+        return False
+    os.remove(path)
+    return True
+
+
+def update_insights_run(batch_evaluation_id: str, updates: dict[str, Any]) -> None:
+    record = {**load_insights_run(batch_evaluation_id), **updates}
+    _write(os.path.join(_insights_dir(), f"{batch_evaluation_id}.json"), record)

agentcore/operations/insights/run_insights.py

@@ -0,0 +1,148 @@
+"""Legacy insights runner (port of operations/insights/run-insights.ts; unused by upstream commands)."""
+
+import random
+import string
+import time
+from collections.abc import Callable
+from typing import Any
+
+from agentcore.aws import agentcore_batch_evaluation as api
+from agentcore.aws.cloudwatch import resolve_endpoint_name, runtime_log_group
+from agentcore.cli.commands.shared.region_utils import get_region
+from agentcore.lib import ConfigIO, ResourceNotFoundError
+from agentcore.lib.errors.types import to_error
+from agentcore.lib.result import Err, Ok
+from agentcore.lib.utils.json_format import to_json_string
+from agentcore.operations.insights.insights_storage import save_insights_run, update_insights_run
+from agentcore.operations.jobs.batch_evaluation.handler import new_logger
+from agentcore.operations.jobs.shared.format import iso_from_ms, iso_now
+from agentcore.operations.jobs.shared.resolve_agent_state import deployed_dict, resolve_agent_state
+
+DEFAULT_POLL_INTERVAL_MS = 5_000
+DEFAULT_LOOKBACK_DAYS = 7
+TERMINAL_STATUSES = frozenset({"COMPLETED", "FAILED", "COMPLETED_WITH_ERRORS", "STOPPED", "CANCELLED"})
+
+
+def _filter_config(options: dict[str, Any]) -> dict[str, Any]:
+    if options.get("sessionIds"):
+        return {"sessionIds": options["sessionIds"]}
+    days = options.get("lookbackDays") or DEFAULT_LOOKBACK_DAYS
+    end = options.get("endTime") or iso_now()
+    start = options.get("startTime") or iso_from_ms(time.time() * 1000 - days * 24 * 60 * 60 * 1000)
+    return {"timeRange": {"startTime": start, "endTime": end}}
+
+
+def run_insights_command(options: dict[str, Any], sleep: Callable[[float], None] = time.sleep) -> Ok | Err:
+    logger = new_logger("insights")
+    log_path = logger.log_file_path if logger else None
+    try:
+        if logger:
+            logger.start_step("Load project config")
+        config_io = ConfigIO()
+        project = config_io.read_project_spec()
+        deployed = deployed_dict(config_io.read_deployed_state())
+        region = get_region(options.get("region"))
+        if logger:
+            logger.log(f"Region: {region}")
+            logger.end_step("success")
+            logger.start_step("Build data source config")
+        if options.get("onlineEvalConfigArn"):
+            data_source: dict[str, Any] = {
+                "onlineEvaluationConfigSource": {"onlineEvaluationConfigArn": options["onlineEvalConfigArn"]}
+            }
+        else:
+            agent = options.get("agent")
+            if not agent:
+                error = "Agent name is required when not using --online-eval-config-arn"
+                if logger:
+                    logger.log(error, "error")
+                    logger.end_step("error", error)
+                    logger.finalize(False)
+                return Err(ResourceNotFoundError(error), logFilePath=log_path)
+            state = resolve_agent_state(deployed, agent)
+            if not state:
+                error = f'Agent "{agent}" not deployed. Run `agentcore deploy` first.'
+                if logger:
+                    logger.log(error, "error")
+                    logger.end_step("error", error)
+                    logger.finalize(False)
+                return Err(ResourceNotFoundError(error), logFilePath=log_path)
+            data_source = {
+                "cloudWatchLogs": {
+                    "serviceNames": [f"{project.name}_{agent}.{resolve_endpoint_name(options.get('endpoint'))}"],
+                    "logGroupNames": [runtime_log_group(state["runtimeId"], options.get("endpoint"))],
+                    "filterConfig": _filter_config(options),
+                }
+            }
+        if logger:
+            logger.end_step("success")
+        date_str = iso_now()[:10].replace("-", "")
+        rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+        name = options.get("name") or f"{options.get('agent') or 'insights'}_insights_{date_str}_{rand}"
+        if logger:
+            logger.start_step("Start insights job")
+        on_progress = options.get("onProgress") or (lambda _s, _m: None)
+        on_progress("starting", f'Starting insights job "{name}"...')
+        start = api.start_batch_evaluation(
+            region=region,
+            name=name,
+            insights=[{"insightId": i} for i in options.get("insights") or []],
+            evaluators=[{"evaluatorId": e} for e in options.get("evaluators") or []] or None,
+            data_source_config=data_source,  # type: ignore[arg-type]
+            client_token=api.generate_client_token(),
+        )
+        if logger:
+            logger.log(f"Response: {to_json_string(start)}")
+            logger.end_step("success")
+        on_progress("running", f"Insights job started (ID: {start['batchEvaluationId']})")
+        if options.get("onStarted"):
+            options["onStarted"]({"batchEvaluationId": start["batchEvaluationId"], "region": region})
+        record: dict[str, Any] = {
+            "batchEvaluationId": start["batchEvaluationId"],
+            "batchEvaluationArn": start["batchEvaluationArn"],
+            "name": start["name"],
+            "status": start["status"],
+            "region": region,
+            "createdAt": start.get("createdAt"),
+            "insights": options.get("insights") or [],
+            "agent": options.get("agent"),
+        }
+        save_insights_run(record)
+        if options.get("wait"):
+            interval = options.get("pollIntervalMs") or DEFAULT_POLL_INTERVAL_MS
+            while record["status"] not in TERMINAL_STATUSES:
+                sleep(interval / 1000)
+                current = api.get_batch_evaluation(region=region, batch_evaluation_id=start["batchEvaluationId"])
+                record["status"] = current["status"]
+                results = current.get("evaluationResults")
+                if results:
+                    record["sessionCount"] = results.get("totalNumberOfSessions")
+                    record["sessionsCompleted"] = results.get("numberOfSessionsCompleted")
+                    record["sessionsFailed"] = results.get("numberOfSessionsFailed")
+                if current["status"] in TERMINAL_STATUSES:
+                    record["completedAt"] = current.get("updatedAt")
+                update_insights_run(start["batchEvaluationId"], record)
+                on_progress(current["status"], f"Status: {current['status']}")
+        if logger:
+            logger.finalize(True)
+        return Ok(
+            {
+                k: record.get(k)
+                for k in (
+                    "batchEvaluationId",
+                    "batchEvaluationArn",
+                    "name",
+                    "status",
+                    "region",
+                    "sessionCount",
+                    "sessionsCompleted",
+                    "sessionsFailed",
+                )
+            }
+            | {"logFilePath": log_path}
+        )
+    except Exception as exc:  # noqa: BLE001
+        if logger:
+            logger.log(str(exc), "error")
+            logger.finalize(False)
+        return Err(to_error(exc), logFilePath=log_path)

agentcore/operations/invoke/__init__.py

@@ -0,0 +1,5 @@
+"""Invocation helpers shared across commands (port of src/cli/operations/invoke)."""
+
+from agentcore.operations.invoke.resolve_agent_context import AgentContext, resolve_agent_context
+
+__all__ = ["AgentContext", "resolve_agent_context"]

agentcore/operations/invoke/resolve_agent_context.py

@@ -0,0 +1,85 @@
+"""Port of operations/invoke/resolve-agent-context.ts.
+
+Resolves a deployed agent to its invocation context (runtime ARN, region, config bundle baggage,
+bearer token) once, so callers (invoke, dataset eval scenarios) can reuse it across invocations.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AgentContext:
+    runtime_arn: str
+    runtime_id: str
+    region: str
+    agent_name: str
+    endpoint: str | None = None
+    baggage: str | None = None
+    bearer_token: str | None = None
+
+
+def resolve_agent_context(
+    *,
+    project: Any,
+    deployed_state: Any,
+    aws_targets: list[Any],
+    agent_name: str | None = None,
+    endpoint: str | None = None,
+    target_name: str | None = None,
+) -> AgentContext:
+    from agentcore.cli.commands.invoke import _deps
+    from agentcore.cli.commands.invoke.resolve import build_config_bundle_baggage
+
+    targets = deployed_state.targets or {}
+    target_names = list(targets)
+    if not target_names:
+        raise RuntimeError("No deployed targets found. Run `agentcore deploy` first.")
+
+    selected = target_name if target_name is not None else target_names[0]
+    if target_name and target_name not in target_names:
+        raise RuntimeError(f"Target '{target_name}' not found. Available: {', '.join(target_names)}")
+
+    target_state = targets.get(selected)
+    target_config = next((t for t in aws_targets if t.name == selected), None)
+    if target_config is None:
+        raise RuntimeError(f"Target config '{selected}' not found in aws-targets")
+
+    runtimes = project.runtimes or []
+    if not runtimes:
+        raise RuntimeError("No agents defined in configuration")
+
+    agent_spec = next((a for a in runtimes if a.name == agent_name), None) if agent_name else runtimes[0]
+    if agent_spec is None:
+        available = ", ".join(a.name for a in runtimes)
+        raise RuntimeError(f"Agent '{agent_name}' not found. Available: {available}")
+
+    resources = target_state.resources if target_state else None
+    agent_state = ((resources.runtimes if resources else None) or {}).get(agent_spec.name)
+    if not agent_state:
+        raise RuntimeError(f"Agent '{agent_spec.name}' is not deployed to target '{selected}'")
+
+    baggage = build_config_bundle_baggage(project, target_state, agent_spec.name)
+
+    bearer_token: str | None = None
+    if agent_spec.authorizer_type == "CUSTOM_JWT":
+        if _deps.can_fetch_runtime_token(agent_spec.name):
+            try:
+                bearer_token = _deps.token_of(_deps.fetch_runtime_token(agent_spec.name, deploy_target=selected))
+            except Exception as exc:
+                raise RuntimeError(f"CUSTOM_JWT agent requires a bearer token. Auto-fetch failed: {exc}") from exc
+        else:
+            raise RuntimeError(
+                f"Agent '{agent_spec.name}' is configured for CUSTOM_JWT but no bearer token is available. "
+                "Re-add the agent with --client-id and --client-secret to enable auto-fetch."
+            )
+
+    return AgentContext(
+        runtime_arn=agent_state.runtime_arn,
+        runtime_id=agent_state.runtime_id,
+        region=target_config.region,
+        endpoint=endpoint,
+        agent_name=agent_spec.name,
+        baggage=baggage,
+        bearer_token=bearer_token,
+    )

agentcore/operations/jobs/__init__.py

@@ -0,0 +1,38 @@
+"""Job Engine public API (port of operations/jobs/index.ts).
+
+Usage::
+
+    engine = create_job_engine(ConfigIO())
+    result = engine.start("recommendation", opts)
+    jobs = engine.list(type="recommendation")
+"""
+
+from agentcore.operations.jobs.batch_evaluation.dataset_phase1 import BATCH_INGESTION_DELAY_MS, run_dataset_phase1
+from agentcore.operations.jobs.shared.constants import (
+    JOB_CAPABILITIES,
+    JOB_TYPE_LABELS,
+    JOB_TYPES,
+    NOT_FOUND_STATUS,
+    STORAGE_DIRS,
+    TERMINAL_STATUSES,
+    is_terminal,
+)
+from agentcore.operations.jobs.shared.engine import JobEngine, create_job_engine
+from agentcore.operations.jobs.shared.region import region_from_arn
+from agentcore.operations.jobs.shared.wait import wait_for_terminal
+
+__all__ = [
+    "BATCH_INGESTION_DELAY_MS",
+    "JOB_CAPABILITIES",
+    "JOB_TYPES",
+    "JOB_TYPE_LABELS",
+    "NOT_FOUND_STATUS",
+    "STORAGE_DIRS",
+    "TERMINAL_STATUSES",
+    "JobEngine",
+    "create_job_engine",
+    "is_terminal",
+    "region_from_arn",
+    "run_dataset_phase1",
+    "wait_for_terminal",
+]

agentcore/operations/jobs/ab_test/build_options.py

@@ -0,0 +1,126 @@
+"""Build the CreateABTest request (port of operations/jobs/ab-test/build-options.ts)."""
+
+from typing import Any
+
+from agentcore.lib import ResourceNotFoundError, ValidationError
+from agentcore.operations.jobs.ab_test.resolve import (
+    resolve_config_bundle_arn,
+    resolve_config_bundle_version,
+    resolve_online_eval_arn,
+)
+
+_NOT_DEPLOYED_BUNDLE = (
+    'Config bundle "{}" is not deployed. Run `agentcore add config-bundle` and `agentcore deploy` first.'
+)
+_BAD_VERSION = (
+    'Could not resolve version "{}" for config bundle "{}". Use LATEST or a version UUID '
+    "(e.g. a1b2c3d4-e5f6-7890-abcd-ef1234567890)."
+)
+
+
+def build_ab_test_request(opts: dict[str, Any], deployed: dict[str, Any] | None = None) -> dict[str, Any]:
+    """{"variants", "evaluationConfig", "gatewayFilter"?, "variantSummaries"}; raises on missing inputs."""
+    variants: list[dict[str, Any]] = []
+    summaries: list[dict[str, Any]] = []
+    cw, tw = opts["controlWeight"], opts["treatmentWeight"]
+
+    if opts["mode"] == "config-bundle":
+        cb, cv = opts.get("controlBundle"), opts.get("controlVersion")
+        tb, tv = opts.get("treatmentBundle"), opts.get("treatmentVersion")
+        if not cb or not cv or not tb or not tv:
+            raise ValidationError("config-bundle A/B test requires control and treatment bundle names and versions.")
+        if not opts.get("onlineEval"):
+            raise ValidationError("config-bundle A/B test requires an online-eval config.")
+        control_arn = resolve_config_bundle_arn(cb, deployed)
+        control_ver = resolve_config_bundle_version(cb, cv, deployed)
+        treatment_arn = resolve_config_bundle_arn(tb, deployed)
+        treatment_ver = resolve_config_bundle_version(tb, tv, deployed)
+        if not control_arn:
+            raise ResourceNotFoundError(_NOT_DEPLOYED_BUNDLE.format(cb))
+        if not control_ver:
+            raise ResourceNotFoundError(_BAD_VERSION.format(cv, cb))
+        if not treatment_arn:
+            raise ResourceNotFoundError(_NOT_DEPLOYED_BUNDLE.format(tb))
+        if not treatment_ver:
+            raise ResourceNotFoundError(_BAD_VERSION.format(tv, tb))
+        variants += [
+            {
+                "name": "C",
+                "weight": cw,
+                "variantConfiguration": {
+                    "configurationBundle": {"bundleArn": control_arn, "bundleVersion": control_ver}
+                },
+            },
+            {
+                "name": "T1",
+                "weight": tw,
+                "variantConfiguration": {
+                    "configurationBundle": {"bundleArn": treatment_arn, "bundleVersion": treatment_ver}
+                },
+            },
+        ]
+        summaries += [
+            {"name": "C", "weight": cw, "bundleArn": control_arn, "bundleVersion": control_ver},
+            {"name": "T1", "weight": tw, "bundleArn": treatment_arn, "bundleVersion": treatment_ver},
+        ]
+        online_arn = resolve_online_eval_arn(opts["onlineEval"], deployed)
+        if not online_arn:
+            raise ResourceNotFoundError(
+                f'Online-eval config "{opts["onlineEval"]}" is not deployed. Run `agentcore add online-eval` and '
+                "`agentcore deploy` first."
+            )
+        evaluation_config: dict[str, Any] = {"onlineEvaluationConfigArn": online_arn}
+    else:
+        ct, tt = opts.get("controlTarget"), opts.get("treatmentTarget")
+        if not ct or not tt:
+            raise ValidationError("target-based A/B test requires control and treatment target names.")
+        variants += [
+            {"name": "C", "weight": cw, "variantConfiguration": {"target": {"name": ct}}},
+            {"name": "T1", "weight": tw, "variantConfiguration": {"target": {"name": tt}}},
+        ]
+        summaries += [
+            {"name": "C", "weight": cw, "targetName": ct},
+            {"name": "T1", "weight": tw, "targetName": tt},
+        ]
+        coe, toe = opts.get("controlOnlineEval"), opts.get("treatmentOnlineEval")
+        if not coe or not toe:
+            raise ValidationError(
+                "target-based A/B test requires --control-online-eval and --treatment-online-eval (one per endpoint)."
+            )
+        control_eval = resolve_online_eval_arn(coe, deployed)
+        if not control_eval:
+            raise ResourceNotFoundError(
+                f'Online-eval config "{coe}" (--control-online-eval) is not deployed. Run `agentcore add online-eval` '
+                "and `agentcore deploy` first."
+            )
+        treatment_eval = resolve_online_eval_arn(toe, deployed)
+        if not treatment_eval:
+            raise ResourceNotFoundError(
+                f'Online-eval config "{toe}" (--treatment-online-eval) is not deployed. Run `agentcore add '
+                "online-eval` and `agentcore deploy` first."
+            )
+        evaluation_config = {
+            "perVariantOnlineEvaluationConfig": [
+                {"name": "C", "onlineEvaluationConfigArn": control_eval},
+                {"name": "T1", "onlineEvaluationConfigArn": treatment_eval},
+            ]
+        }
+
+    gateway_filter = None
+    if opts.get("gatewayFilter"):
+        paths = [s.strip() for s in opts["gatewayFilter"].split(",") if s.strip()]
+        if len(paths) > 1:
+            quoted = ", ".join(f'"{p}"' for p in paths)
+            raise ValidationError(
+                "--gateway-filter accepts exactly one target path pattern (the service allows a single path). "
+                f"Got {len(paths)}: {quoted}."
+            )
+        if len(paths) == 1:
+            gateway_filter = {"targetPaths": [paths[0]]}
+
+    return {
+        "variants": variants,
+        "evaluationConfig": evaluation_config,
+        "gatewayFilter": gateway_filter,
+        "variantSummaries": summaries,
+    }

agentcore/operations/jobs/ab_test/format.py

@@ -0,0 +1,121 @@
+"""Presentation helpers for A/B-test jobs (port of operations/jobs/ab-test/format.ts)."""
+
+from typing import Any
+
+import typer
+
+from agentcore.aws.partition import dns_suffix
+from agentcore.operations.jobs.shared.format import format_job_date, to_fixed
+
+# Names what the caller must append to a gateway base URL to reach a variant.
+INVOCATION_PATH_HINT = "append /<gateway-target>/invocations (see `agentcore status --json`)"
+
+
+def _gateway_base_url(record: dict[str, Any]) -> str | None:
+    parts = (record.get("gatewayArn") or "").split(":")
+    region = parts[3] if len(parts) > 3 else ""
+    resource = parts[5].split("/") if len(parts) > 5 else []
+    gateway_id = resource[1] if len(resource) > 1 else ""
+    if not region or not gateway_id:
+        return None
+    return f"https://{gateway_id}.gateway.bedrock-agentcore.{region}.{dns_suffix(region)}"
+
+
+def _unique_target_name(record: dict[str, Any]) -> str | None:
+    if record.get("mode") == "target-based":
+        variants = record.get("variants") or []
+        return variants[0].get("targetName") if variants else None
+    return record.get("targetName")
+
+
+def get_invocation_url(record: dict[str, Any]) -> str | None:
+    base = _gateway_base_url(record)
+    target = _unique_target_name(record)
+    return f"{base}/{target}/invocations" if base and target else None
+
+
+def get_invocation_url_candidates(record: dict[str, Any]) -> list[str]:
+    base = _gateway_base_url(record)
+    if not base or not record.get("targetCandidates"):
+        return []
+    return [f"{base}/{t}/invocations" for t in record["targetCandidates"]]
+
+
+def get_gateway_base_url(record: dict[str, Any]) -> str | None:
+    return _gateway_base_url(record)
+
+
+def print_ab_test_history(records: list[dict[str, Any]]) -> None:
+    if not records:
+        typer.echo("No A/B test jobs found. Run `agentcore run ab-test` to create one.")
+        return
+    typer.echo(f"\n{'Date'.ljust(22)} {'Execution'.ljust(12)} {'Lifecycle'.ljust(12)} {'Name'.ljust(24)} ID")
+    typer.echo("─" * 100)
+    for r in records:
+        typer.echo(
+            f"{format_job_date(r.get('createdAt')).ljust(22)} {str(r.get('status')).ljust(12)} "
+            f"{str(r.get('lifecycleStatus')).ljust(12)} {str(r.get('name')).ljust(24)} {r['id']}"
+        )
+    typer.echo("")
+
+
+def print_ab_test_detail(record: dict[str, Any]) -> None:
+    typer.echo(f"\nA/B test: {record['id']}")
+    typer.echo(f"Name: {record.get('name')}")
+    typer.echo(f"Mode: {record.get('mode')}")
+    typer.echo(f"Execution status: {record.get('status')}")
+    typer.echo(f"Lifecycle status: {record.get('lifecycleStatus')}")
+    typer.echo(f"Gateway: {record.get('gatewayArn')}")
+    paths = (record.get("gatewayFilter") or {}).get("targetPaths") or []
+    typer.echo(f"Gateway filter: {paths[0] if paths else 'none'}")
+    url = get_invocation_url(record)
+    candidates = get_invocation_url_candidates(record)
+    if url:
+        typer.echo(f"Invocation URL: {url}")
+    elif candidates:
+        typer.echo("Invocation URLs (one per matching gateway target — pick the one to send traffic to):")
+        for c in candidates:
+            typer.echo(f"  {c}")
+    else:
+        base = get_gateway_base_url(record)
+        if base:
+            typer.echo(f"Gateway URL: {base}")
+            typer.echo(f"  → {INVOCATION_PATH_HINT}")
+    typer.echo(f"Started: {format_job_date(record.get('createdAt'))}")
+    if record.get("completedAt"):
+        typer.echo(f"Stopped: {format_job_date(record['completedAt'])}")
+    if record.get("maxDurationExpiresAt"):
+        typer.echo(f"Max duration expires: {format_job_date(record['maxDurationExpiresAt'])}")
+
+    typer.echo("\nVariants:")
+    for v in record.get("variants") or []:
+        if v.get("bundleArn"):
+            detail = f"bundle {v['bundleArn']} @ {v.get('bundleVersion')}"
+        elif v.get("targetName"):
+            detail = f"target {v['targetName']}"
+        else:
+            detail = "(unspecified)"
+        typer.echo(f"  {v.get('name')} (weight {v.get('weight')}): {detail}")
+
+    metrics = (record.get("results") or {}).get("evaluatorMetrics")
+    if metrics:
+        typer.echo("\nResults:")
+        for m in metrics:
+            typer.echo(f"  {m.get('evaluatorArn')}")
+            cs = m.get("controlStats") or {}
+            typer.echo(f"    C (n={cs.get('sampleSize')}): mean {to_fixed(cs.get('mean'), 3)}")
+            for vr in m.get("variantResults") or []:
+                pc = vr.get("percentChange")
+                change = f" ({'+' if pc > 0 else ''}{to_fixed(pc, 1)}%)" if pc is not None else ""
+                sig = " *significant*" if vr.get("isSignificant") else ""
+                typer.echo(
+                    f"    {vr.get('treatmentName')} (n={vr.get('sampleSize')}): mean {to_fixed(vr.get('mean'), 3)}"
+                    f"{change}{sig}"
+                )
+    elif record.get("failureReason"):
+        typer.echo(f"\nFailure: {record['failureReason']}")
+    else:
+        typer.echo("\nResults not yet available.")
+    if record.get("logFilePath"):
+        typer.echo(f"\nLog: {record['logFilePath']}")
+    typer.echo("")