alloy-runtime-cli 0.2.70__tar.gz → 0.2.71__tar.gz

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.70
+Version: 0.2.71
 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.70
-Requires-Dist: alloy-runtime-types==0.2.70
+Requires-Dist: alloy-runtime-sdk==0.2.71
+Requires-Dist: alloy-runtime-types==0.2.71
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -74,9 +74,10 @@ For live model-execution inspection, use:
 ```bash
 alloy executions get <execution_id>
 alloy executions get <execution_id> --watch
+alloy executions get <execution_id> --full-output
 ```
 
-`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 and waits indefinitely unless you pass `--timeout <seconds>`.
+`alloy executions get` uses a dedicated transcript view for human output: one metadata header followed by chronological reasoning, tool-call, tool-output, and assistant blocks. Tool inputs are always complete; tool outputs are compact by default, and `--full-output` expands them. `--watch` appends only newly observed activity blocks while the execution is still running and waits indefinitely unless you pass `--timeout <seconds>`.
 
 `alloy ping` is the authenticated connectivity check. It confirms who you are, which host you reached, and which server build answered the request.
 

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/README.md

@@ -52,9 +52,10 @@ For live model-execution inspection, use:
 ```bash
 alloy executions get <execution_id>
 alloy executions get <execution_id> --watch
+alloy executions get <execution_id> --full-output
 ```
 
-`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 and waits indefinitely unless you pass `--timeout <seconds>`.
+`alloy executions get` uses a dedicated transcript view for human output: one metadata header followed by chronological reasoning, tool-call, tool-output, and assistant blocks. Tool inputs are always complete; tool outputs are compact by default, and `--full-output` expands them. `--watch` appends only newly observed activity blocks while the execution is still running and waits indefinitely unless you pass `--timeout <seconds>`.
 
 `alloy ping` is the authenticated connectivity check. It confirms who you are, which host you reached, and which server build answered the request.
 

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/alloy_runtime_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.70
+Version: 0.2.71
 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.70
-Requires-Dist: alloy-runtime-types==0.2.70
+Requires-Dist: alloy-runtime-sdk==0.2.71
+Requires-Dist: alloy-runtime-types==0.2.71
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -74,9 +74,10 @@ For live model-execution inspection, use:
 ```bash
 alloy executions get <execution_id>
 alloy executions get <execution_id> --watch
+alloy executions get <execution_id> --full-output
 ```
 
-`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 and waits indefinitely unless you pass `--timeout <seconds>`.
+`alloy executions get` uses a dedicated transcript view for human output: one metadata header followed by chronological reasoning, tool-call, tool-output, and assistant blocks. Tool inputs are always complete; tool outputs are compact by default, and `--full-output` expands them. `--watch` appends only newly observed activity blocks while the execution is still running and waits indefinitely unless you pass `--timeout <seconds>`.
 
 `alloy ping` is the authenticated connectivity check. It confirms who you are, which host you reached, and which server build answered the request.
 

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/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.70
-alloy-runtime-types==0.2.70
+alloy-runtime-sdk==0.2.71
+alloy-runtime-types==0.2.71
 trogon==0.6.0

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/cli/commands/executions/get/command.py

@@ -23,11 +23,17 @@ def executions_get_command(
         "--timeout",
         help="Maximum seconds to wait when using --watch (default: wait indefinitely)",
     ),
+    full_output: bool = typer.Option(
+        False,
+        "--full-output",
+        help="Show full tool outputs instead of compact truncation",
+    ),
 ) -> None:
     _execute_get(
         execution_id=validate_uuid(execution_id, "execution"),
         watch=watch,
         timeout=timeout,
+        full_output=full_output,
     )
 
 
@@ -36,11 +42,12 @@ async def _execute_get(
     execution_id: UUID,
     watch: bool,
     timeout: float | None,
+    full_output: bool,
 ) -> None:
     async with authenticated_client() as (_config, client):
         if not watch:
             response = await client.get_execution(execution_id)
-            present_execution(response)
+            present_execution(response, full_output=full_output)
             return
 
         output = OutputService.get()
@@ -68,7 +75,9 @@ async def _execute_get(
             rendered_count = present_execution(
                 response,
                 include_metadata=not metadata_rendered,
+                include_appendices=response.is_terminal,
                 start_index=rendered_count,
+                full_output=full_output,
             )
             metadata_rendered = True
             if response.is_terminal:

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/cli/commands/executions/get/presenter.py

@@ -11,7 +11,9 @@ def present_execution(
     response: GetExecutionResponse,
     *,
     include_metadata: bool = True,
+    include_appendices: bool | None = None,
     start_index: int = 0,
+    full_output: bool = False,
 ) -> int:
     output = OutputService.get()
     if output.format == OutputFormat.JSON:
@@ -25,24 +27,19 @@ def present_execution(
     activity_blocks = render_activity_blocks(
         response.activity,
         start_index=start_index,
+        full_output=full_output,
     )
     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:
+    should_render_appendices = (
+        include_metadata if include_appendices is None else include_appendices
+    )
+    if should_render_appendices:
         appendices = render_appendices(response)
         if appendices:
-            if blocks:
-                blocks.append(
-                    "────────────────────────────────────────────────────────────"
-                )
             blocks.append(appendices)
 
     rendered = "\n\n".join(blocks).rstrip()

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

@@ -0,0 +1,370 @@
+import json
+import textwrap
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, cast
+
+from alloy_runtime_types.dtos.executions import (
+    AssistantTextActivity,
+    ExecutionActivityItem,
+    GetExecutionResponse,
+    ReasoningActivity,
+    ToolCallActivity,
+    ToolOutputActivity,
+)
+from rich.markup import escape
+
+
+@dataclass(frozen=True)
+class KindDescriptor:
+    label: str
+    style: str
+
+
+KIND_DESCRIPTORS: dict[str, KindDescriptor] = {
+    "reasoning": KindDescriptor("REASONING", "dim cyan"),
+    "assistant_text": KindDescriptor("ASSISTANT", "bold"),
+    "tool_call": KindDescriptor("TOOL CALL", "magenta"),
+    "tool_output": KindDescriptor("TOOL OUTPUT", "green"),
+    "tool_error": KindDescriptor("TOOL ERROR", "bold red"),
+}
+
+RULE = "─" * 80
+
+
+def render_execution_header(response: GetExecutionResponse, *, width: int = 80) -> str:
+    execution_id = f"{str(response.execution_id)[:8]}…"
+    duration = _format_duration(response.total_duration_ms)
+    rounds = (
+        _plural(response.round_count, "round")
+        if response.round_count is not None
+        else "0 rounds"
+    )
+    activity = _plural(len(response.activity), "activity item")
+    lines = [
+        "Execution  "
+        f"{escape(execution_id)}  ·  "
+        f"{_styled(escape(response.status), _status_style(response.status))}  ·  "
+        f"{escape(duration)}  ·  {escape(rounds)}  ·  {escape(activity)}"
+    ]
+
+    provider = _provider_line(response)
+    if provider:
+        lines.append(provider)
+
+    times = _times_line(response)
+    if times:
+        lines.append(times)
+
+    if response.error_message:
+        lines.append(f"Error      {_styled(escape(response.error_message), 'red')}")
+
+    lines.append(_styled(escape(RULE[:width]), "dim"))
+    return "\n".join(lines)
+
+
+def render_activity_blocks(
+    activities: list[ExecutionActivityItem],
+    *,
+    start_index: int = 0,
+    full_output: bool,
+    width: int = 80,
+) -> str:
+    blocks: list[str] = []
+    for activity in activities[start_index:]:
+        blocks.append(_render_activity(activity, full_output=full_output, width=width))
+    return "\n\n".join(block for block in blocks if block)
+
+
+def render_appendices(response: GetExecutionResponse) -> str:
+    appendices: list[str] = []
+    if response.output_text:
+        appendices.append(f"Final Output\n{escape(response.output_text)}")
+    return "\n\n".join(appendices)
+
+
+def _render_activity(
+    activity: ExecutionActivityItem, *, full_output: bool, width: int
+) -> str:
+    body = ""
+    inline_meta: str | None = None
+    tool_name: str | None = None
+
+    if isinstance(activity, ReasoningActivity):
+        body = _wrap_text(activity.text, width=width, indent="  ", style="dim")
+    elif isinstance(activity, AssistantTextActivity):
+        body = _wrap_text(activity.text, width=width, indent="  ")
+    elif isinstance(activity, ToolCallActivity):
+        tool_name = activity.tool_name
+        body = _format_tool_input(activity.input, width=width)
+    elif isinstance(activity, ToolOutputActivity):
+        tool_name = activity.tool_name
+        body, inline_meta = _dispatch_tool_output(
+            activity.tool_name, activity.output, full=full_output, width=width
+        )
+    else:
+        tool_name = activity.tool_name
+        body = _wrap_text(activity.error, width=width, indent="  ", style="red")
+
+    header = _activity_header(activity, tool_name=tool_name, inline_meta=inline_meta)
+    if not body:
+        return header
+    return f"{header}\n{body}"
+
+
+def _activity_header(
+    activity: ExecutionActivityItem, *, tool_name: str | None, inline_meta: str | None
+) -> str:
+    descriptor = KIND_DESCRIPTORS[activity.kind]
+    pieces = [
+        _styled(escape(_format_time(activity.timestamp)), "dim"),
+        _styled(descriptor.label, descriptor.style),
+    ]
+    if tool_name:
+        pieces.append(_styled(escape(tool_name), "bold"))
+    if inline_meta:
+        pieces.append(_styled(escape(inline_meta), "dim"))
+    return "  ".join(pieces)
+
+
+def _format_tool_input(payload: dict[str, Any], *, width: int) -> str:
+    if not payload:
+        return ""
+    key_width = min(max(len(str(key)) for key in payload), 24)
+    lines: list[str] = []
+    available = max(20, width - 2 - key_width - 2)
+    for key, value in payload.items():
+        key_text = str(key)
+        rendered = _format_input_value(value)
+        prefix = "  " + _styled(escape(key_text.ljust(key_width)), "cyan") + "  "
+        if "\n" not in rendered and len(rendered) <= available:
+            lines.append(prefix + escape(rendered))
+            continue
+        lines.append(prefix.rstrip())
+        for line in rendered.splitlines():
+            lines.append("  " + " " * (key_width + 2) + escape(line))
+    return "\n".join(lines)
+
+
+def _format_input_value(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    compact = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+    if len(compact) <= 80:
+        return compact
+    return json.dumps(value, ensure_ascii=False, indent=2)
+
+
+def _dispatch_tool_output(
+    tool_name: str, payload: dict[str, Any] | list[Any] | str, *, full: bool, width: int
+) -> tuple[str, str | None]:
+    if tool_name == "rag_search" and isinstance(payload, dict):
+        return _format_rag_search(payload, full=full, width=width)
+    return _format_generic(payload, full=full, width=width)
+
+
+def _format_rag_search(
+    payload: dict[str, Any], *, full: bool, width: int
+) -> tuple[str, str | None]:
+    titles = _list_of_strings(payload.get("top_titles"))
+    hits = _int_value(payload.get("hits"), default=len(titles))
+    timing = _int_value(payload.get("timing_ms"), default=None)
+    inline_meta = f"{hits} hits" + (f" · {timing}ms" if timing is not None else "")
+    scores = _list(payload.get("scores"))
+    source_refs = _list(payload.get("source_refs"))
+    chunks = _list(payload.get("chunks"))
+
+    lines: list[str] = []
+    for index, title in enumerate(titles):
+        if not full:
+            lines.append(f"  • {escape(title)}")
+            continue
+        meta_parts: list[str] = []
+        if index < len(scores):
+            meta_parts.append(f"score {_score(scores[index])}")
+        if index < len(source_refs):
+            meta_parts.append(str(source_refs[index]))
+        meta = (
+            f"  {_styled(escape(' · '.join(meta_parts)), 'dim')}" if meta_parts else ""
+        )
+        lines.append(f"  • {escape(title)}{meta}")
+        snippet = _chunk_text(chunks[index]) if index < len(chunks) else None
+        if snippet:
+            lines.extend(
+                escape(line)
+                for line in _wrap_plain(
+                    snippet, width=width, indent="    ", max_lines=2
+                )
+            )
+
+    if not full:
+        lines.append("")
+        lines.append(
+            "  "
+            + _styled(
+                "Use --full-output to see scores, source refs, and content snippets.",
+                "dim",
+            )
+        )
+    return "\n".join(lines), inline_meta
+
+
+def _format_generic(
+    payload: dict[str, Any] | list[Any] | str, *, full: bool, width: int
+) -> tuple[str, str | None]:
+    raw = (
+        payload
+        if isinstance(payload, str)
+        else json.dumps(payload, indent=2, ensure_ascii=False)
+    )
+    wrapped: list[str] = []
+    for line in raw.splitlines() or [""]:
+        wrapped.extend(_wrap_plain(line, width=width, indent="  "))
+    total = len(wrapped)
+    visible = wrapped if full or total <= 12 else wrapped[:12]
+    escaped_lines = [escape(line) for line in visible]
+    if not full and total > 12:
+        escaped_lines.append(
+            "  "
+            + _styled(
+                f"+ {total - 12} more lines — use --full-output to expand",
+                "dim",
+            )
+        )
+    return "\n".join(escaped_lines), _plural(total, "line")
+
+
+def _wrap_text(text: str, *, width: int, indent: str, style: str | None = None) -> str:
+    lines = [escape(line) for line in _wrap_plain(text, width=width, indent=indent)]
+    if style:
+        return "\n".join(_styled(line, style) for line in lines)
+    return "\n".join(lines)
+
+
+def _wrap_plain(
+    text: str, *, width: int, indent: str, max_lines: int | None = None
+) -> list[str]:
+    lines: list[str] = []
+    body_width = max(20, width - len(indent))
+    for source_line in text.splitlines() or [""]:
+        wrapped = textwrap.wrap(
+            source_line,
+            width=body_width,
+            replace_whitespace=False,
+            drop_whitespace=False,
+        ) or [""]
+        for line in wrapped:
+            lines.append(indent + line)
+            if max_lines is not None and len(lines) >= max_lines:
+                return lines
+    return lines
+
+
+def _provider_line(response: GetExecutionResponse) -> str | None:
+    if (
+        not response.provider_key
+        and not response.provider_model_name
+        and not response.origin_label
+    ):
+        return None
+    provider = (
+        f"{response.provider_key} / {response.provider_model_name}"
+        if response.provider_key or response.provider_model_name
+        else ""
+    )
+    return f"Provider   {escape(provider)}  ·  origin: {escape(response.origin_label)}"
+
+
+def _times_line(response: GetExecutionResponse) -> str | None:
+    parts: list[str] = []
+    include_completed_date = (
+        isinstance(response.completed_at, datetime)
+        and response.queued_at.date() != response.completed_at.date()
+    )
+    if response.queued_at:
+        parts.append(f"queued {_format_time(response.queued_at)}")
+    if response.started_at:
+        parts.append(f"started {_format_time(response.started_at)}")
+    if response.completed_at:
+        parts.append(
+            "completed "
+            + (
+                response.completed_at.strftime("%Y-%m-%d %H:%M:%S")
+                if include_completed_date
+                else _format_time(response.completed_at)
+            )
+        )
+    if not parts:
+        return None
+    return "Times      " + escape("  ·  ".join(parts))
+
+
+def _format_duration(total_duration_ms: int | None) -> str:
+    if total_duration_ms is None:
+        return "(running)"
+    seconds = total_duration_ms / 1000
+    return f"{seconds:.1f}s" if seconds < 60 else f"{seconds / 60:.1f}m"
+
+
+def _format_time(value: Any) -> str:
+    if not isinstance(value, datetime):
+        return "--:--:--"
+    return value.strftime("%H:%M:%S")
+
+
+def _status_style(status: str) -> str:
+    if status in {"failed", "cancelled", "timeout"}:
+        return "bold red"
+    if status in {"completed", "succeeded"}:
+        return "green"
+    return "yellow"
+
+
+def _plural(count: int, noun: str) -> str:
+    return f"{count} {noun}" if count == 1 else f"{count} {noun}s"
+
+
+def _list(value: Any) -> list[Any]:
+    return cast(list[Any], value) if isinstance(value, list) else []
+
+
+def _list_of_strings(value: Any) -> list[str]:
+    items = cast(list[object], value) if isinstance(value, list) else []
+    return [str(item) for item in items]
+
+
+def _int_value(value: Any, *, default: int | None) -> int | None:
+    if isinstance(value, bool):
+        return default
+    if isinstance(value, int):
+        return value
+    return default
+
+
+def _score(value: Any) -> str:
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return f"{float(value):.2f}"
+    return str(value)
+
+
+def _chunk_text(value: Any) -> str | None:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict):
+        mapping = cast(dict[str, object], value)
+        text = mapping.get("text")
+        if isinstance(text, str):
+            return text
+    return None
+
+
+def _styled(content: str, style: str) -> str:
+    return _open_tag(style) + content + _close_tag(style)
+
+
+def _open_tag(style: str) -> str:
+    return "[" + style + "]"
+
+
+def _close_tag(style: str) -> str:
+    return "[/" + style + "]"

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/cli/commands/knowledge/documents/count/presenter.py

@@ -6,6 +6,7 @@ from alloy_runtime_types.dtos.knowledge import (
     CountDocumentsResponse,
     DOCUMENT_STATUS_ORDER,
 )
+from rich.markup import escape
 
 from cli.infrastructure.output import OutputService
 
@@ -15,11 +16,11 @@ def present_documents_count(
 ) -> None:
     output = OutputService.get()
     if output_json:
-        output.text(json.dumps(response.model_dump(mode="json"), indent=2))
+        output.text(escape(json.dumps(response.model_dump(mode="json"), indent=2)))
         return
 
-    output.text(f"Total documents: {response.count}")
+    output.text(f"Total documents: {escape(str(response.count))}")
     breakdown = response.breakdown_by_status.model_dump()
     output.text("By status:")
     for status in DOCUMENT_STATUS_ORDER:
-        output.text(f"  {status}: {breakdown[status]}")
+        output.text(f"  {escape(status)}: {escape(str(breakdown[status]))}")

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/cli/commands/knowledge/documents/list/presenter.py

@@ -4,6 +4,7 @@ from alloy_runtime_types.dtos.knowledge import (
     DOCUMENT_STATUS_ORDER,
     ListDocumentsResponse,
 )
+from rich.markup import escape
 
 from cli.infrastructure.output import OutputService
 from cli.infrastructure.renderers.list_renderer import ColumnConfig
@@ -88,5 +89,8 @@ def present_documents_list(response: ListDocumentsResponse) -> None:
     breakdown = response.breakdown_by_status.model_dump()
     output.text(
         "By status: "
-        + ", ".join(f"{status}={breakdown[status]}" for status in DOCUMENT_STATUS_ORDER)
+        + ", ".join(
+            f"{escape(status)}={escape(str(breakdown[status]))}"
+            for status in DOCUMENT_STATUS_ORDER
+        )
     )

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/cli/infrastructure/output.py

@@ -6,6 +6,7 @@ from enum import Enum
 from typing import Any, cast
 
 from pydantic import BaseModel
+from rich.console import Console
 
 from cli.infrastructure.console import get_console
 from cli.infrastructure.formatters.base import Formatter
@@ -37,14 +38,18 @@ class OutputService:
     _instance: "OutputService | None" = None
     _format: OutputFormat = OutputFormat.COMPACT
 
-    def __init__(self, format: OutputFormat = OutputFormat.COMPACT):
+    def __init__(
+        self,
+        format: OutputFormat = OutputFormat.COMPACT,
+        console: Console | None = None,
+    ):
         """Initialize output service with specified format.
 
         Args:
             format: Output mode for record blocks or raw JSON payloads
         """
         self.format = format
-        self._console = get_console()
+        self._console = console if console is not None else get_console()
         self._formatter = self._create_formatter(format)
         self._entity_renderer = EntityRenderer(self._formatter)
         self._list_renderer = ListRenderer(self._formatter)
@@ -114,7 +119,7 @@ class OutputService:
         self._write_raw_stdout(json.dumps(jsonable, indent=2, default=str))
 
     def text(self, content: str) -> None:
-        self._write_raw_stdout(content)
+        self._console.print(content, markup=True, highlight=False, soft_wrap=False)
 
     def progress(self, message: str) -> None:
         print(message, file=sys.stderr)

{alloy_runtime_cli-0.2.70 → alloy_runtime_cli-0.2.71}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alloy-runtime-cli"
-version = "0.2.70"
+version = "0.2.71"
 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.70",
-  "alloy-runtime-types==0.2.70",
+  "alloy-runtime-sdk==0.2.71",
+  "alloy-runtime-types==0.2.71",
   "trogon==0.6.0",
 ]