vidbyte-cli 0.1.0__py3-none-any.whl

vidbyte_cli/commands/config/get.py

@@ -0,0 +1,45 @@
+"""`vidbyte-cli config get <key>` — reads a non-secret CLI setting.
+
+It reports the *effective* value, not the stored one, so an environment override is visible
+rather than mysterious. Machine output carries the provenance alongside it.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+import click
+
+from ...lib.config import ConfigField
+from ...lib.output import OutputDocument
+from ...lib.runtime.context import ApplicationContext
+
+
+class ConfigGetCommand:
+    def register(self, parent: click.Group) -> None:
+        @parent.command(name="get", help="Read an effective CLI configuration value")
+        @click.argument("key", type=click.Choice([item.value for item in ConfigField]))
+        @click.pass_obj
+        def _run(context: ApplicationContext, key: str) -> None:
+            self.execute(context, ConfigField(key))
+
+    def execute(self, context: ApplicationContext, field: ConfigField) -> None:
+        config = context.resolved_config()
+        value = getattr(config, field.value)
+        serialized = value.value if isinstance(value, Enum) else value
+        source = config.provenance[field]
+        if context.options.debug:
+            context.output().diagnostic(f"{field.value} source: {source.value}")
+        # Human output is the bare value so `$(vidbyte-cli config get api_url)` is usable.
+        context.output().result(
+            OutputDocument(
+                kind="config.value",
+                data={
+                    "profile": config.profile,
+                    "key": field.value,
+                    "value": serialized,
+                    "source": source.value,
+                },
+            ),
+            str(serialized),
+        )

vidbyte_cli/commands/config/set.py

@@ -0,0 +1,39 @@
+"""`vidbyte-cli config set <key> <value>` — writes a non-secret CLI setting.
+
+The value stays a string across Click's boundary and is parsed by `ProfileConfig`, so the
+command line, the environment, and the persisted document all validate the same way.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+import click
+
+from ...lib.config import ConfigField
+from ...lib.output import OutputDocument
+from ...lib.runtime.context import ApplicationContext
+
+
+class ConfigSetCommand:
+    def register(self, parent: click.Group) -> None:
+        @parent.command(name="set", help="Write a CLI configuration value")
+        @click.argument("key", type=click.Choice([item.value for item in ConfigField]))
+        @click.argument("value")
+        @click.pass_obj
+        def _run(context: ApplicationContext, key: str, value: str) -> None:
+            self.execute(context, ConfigField(key), value)
+
+    def execute(self, context: ApplicationContext, field: ConfigField, value: str) -> None:
+        profile = context.options.profile
+        updated = context.config_store().set(field, value, profile)
+        # Echo what was stored, not what was typed: normalization may have changed it.
+        saved = getattr(updated, field.value)
+        serialized = saved.value if isinstance(saved, Enum) else saved
+        context.output().result(
+            OutputDocument(
+                kind="config.updated",
+                data={"profile": profile, "key": field.value, "value": serialized},
+            ),
+            f"Set {field.value} for profile '{profile}' to {serialized}.",
+        )

vidbyte_cli/commands/provider/__init__.py

@@ -0,0 +1,9 @@
+"""Provider commands group export."""
+
+from __future__ import annotations
+
+from .login import ProviderLoginCommand
+from .logout import ProviderLogoutCommand
+from .whoami import ProviderWhoamiCommand
+
+__all__ = ["ProviderLoginCommand", "ProviderLogoutCommand", "ProviderWhoamiCommand"]

vidbyte_cli/commands/provider/login.py

@@ -0,0 +1,102 @@
+"""`vidbyte-cli provider login` — verifies a provider key then stores it."""
+
+from __future__ import annotations
+
+import click
+
+from ...lib.auth.provider_input import ProviderCredentialInput
+from ...lib.errors.failures import FileFallbackNotApprovedForProvider
+from ...lib.output import OutputDocument
+from ...lib.runtime.context import ApplicationContext
+from ...types.provider import Provider
+
+
+class ProviderLoginCommand:
+    """Authenticates a BYOK provider key."""
+
+    def register(self, parent: click.Group) -> None:
+        # Adds `provider login <provider>` with optional stdin and fallback flags.
+        @parent.command(
+            name="login",
+            help="Authenticate a provider API key (openai, claude, grok, deepseek, glm, muse, gemini)",  # noqa: E501
+        )
+        @click.argument("provider", type=click.Choice([p.value for p in Provider]))
+        @click.option(
+            "--with-token",
+            is_flag=True,
+            help="Read the provider key from stdin instead of a hidden prompt.",
+        )
+        @click.option(
+            "--allow-file-fallback",
+            is_flag=True,
+            help="Approve restricted-file storage when no OS keyring is available.",
+        )
+        @click.pass_obj
+        def _run(
+            context: ApplicationContext,
+            provider: str,
+            with_token: bool,
+            allow_file_fallback: bool,
+        ) -> None:
+            self.execute(context, provider, with_token, allow_file_fallback)
+
+    def execute(
+        self,
+        context: ApplicationContext,
+        provider: str,
+        with_token: bool,
+        allow_file_fallback: bool,
+    ) -> None:
+        # Verify-before-persist so a bad key never reaches storage.
+        config = context.resolved_config()
+        typed = Provider(provider)
+        credentials = ProviderCredentialInput(
+            context.streams,
+            context.output().terminal,
+            no_input=context.options.no_input,
+            provider=typed,
+        ).read(from_stdin=with_token)
+        context.provider_verifier(typed).verify(credentials)
+        fallback_allowed = self._fallback_consent(context, allow_file_fallback)
+        context.migration().migrate_if_needed()
+        storage = context.provider_store().write(
+            credentials,
+            config.profile,
+            typed,
+            allow_file_fallback=fallback_allowed,
+        )
+        if storage.value == "restricted_file":
+            context.output().warning(
+                "The provider key is stored in a permission-restricted file because no OS "
+                "keyring is available."
+            )
+        context.output().result(
+            OutputDocument(
+                kind="provider.login",
+                data={
+                    "profile": config.profile,
+                    "provider": typed.value,
+                    "storage": storage.value,
+                },
+            ),
+            (
+                f"Authenticated provider '{typed.value}' for profile "
+                f"'{config.profile}' using {storage.value}."
+            ),
+        )
+
+    def _fallback_consent(self, context: ApplicationContext, explicitly_allowed: bool) -> bool:
+        # Restricted file needs explicit consent when no keyring is available.
+        if context.provider_store().keyring.available():
+            return False
+        if explicitly_allowed:
+            return True
+        if context.options.no_input or not context.output().terminal.interactive:
+            raise FileFallbackNotApprovedForProvider(typed_name="provider")
+        return bool(
+            click.confirm(
+                "No OS keyring is available. Store the provider key in a restricted local file?",
+                default=False,
+                err=True,
+            )
+        )

vidbyte_cli/commands/provider/logout.py

@@ -0,0 +1,45 @@
+"""`vidbyte-cli provider logout` — removes a stored provider key."""
+
+from __future__ import annotations
+
+import click
+
+from ...lib.output import OutputDocument
+from ...lib.runtime.context import ApplicationContext
+from ...types.provider import Provider
+
+
+class ProviderLogoutCommand:
+    """Removes a stored BYOK provider credential."""
+
+    def register(self, parent: click.Group) -> None:
+        # Scoped logout: only the named provider for the active profile is cleared.
+        @parent.command(name="logout", help="Remove a stored provider API key")
+        @click.argument("provider", type=click.Choice([p.value for p in Provider]))
+        @click.pass_obj
+        def _run(context: ApplicationContext, provider: str) -> None:
+            self.execute(context, provider)
+
+    def execute(self, context: ApplicationContext, provider: str) -> None:
+        # Clears keyring and file entries for just this provider.
+        config = context.resolved_config()
+        typed = Provider(provider)
+        removed = context.provider_store().clear(config.profile, typed)
+        context.output().result(
+            OutputDocument(
+                kind="provider.logout",
+                data={
+                    "profile": config.profile,
+                    "provider": typed.value,
+                    "removed": removed,
+                },
+            ),
+            (
+                f"Removed provider '{typed.value}' for profile '{config.profile}'."
+                if removed
+                else (
+                    f"Provider '{typed.value}' was already logged out for profile "
+                    f"'{config.profile}'."
+                )
+            ),
+        )

vidbyte_cli/commands/provider/whoami.py

@@ -0,0 +1,49 @@
+"""`vidbyte-cli provider whoami` — shows which provider key is stored."""
+
+from __future__ import annotations
+
+import click
+from pydantic import JsonValue
+
+from ...lib.output import OutputDocument
+from ...lib.runtime.context import ApplicationContext
+from ...types.provider import Provider
+
+
+class ProviderWhoamiCommand:
+    """Reports the identity behind a stored provider key."""
+
+    def register(self, parent: click.Group) -> None:
+        # Attaches `whoami` to the provider group.
+        @parent.command(name="whoami", help="Show the provider behind stored credentials")
+        @click.argument("provider", type=click.Choice([p.value for p in Provider]))
+        @click.pass_obj
+        def _run(context: ApplicationContext, provider: str) -> None:
+            self.execute(context, provider)
+
+    def execute(self, context: ApplicationContext, provider: str) -> None:
+        # Resolves the stored provider key and re-probes to prove it is live.
+        config = context.resolved_config()
+        typed = Provider(provider)
+        resolved = context.provider_resolver().resolve(config.profile, typed)
+        if resolved is None:
+            # No probe when nothing is stored — mirrors whoami's no-network rule.
+            from ...lib.errors.failures import ProviderAuthenticationRequired
+
+            raise ProviderAuthenticationRequired(typed.value)
+        identity = context.provider_verifier(typed).verify(resolved.credentials)
+        data: dict[str, JsonValue] = {
+            "profile": config.profile,
+            "provider": typed.value,
+            "verified": identity.verified,
+            "credential_source": resolved.source.value,
+        }
+        human = "\n".join(
+            (
+                f"Provider: {typed.value}",
+                f"Verified: {identity.verified}",
+                f"Profile: {config.profile}",
+                f"Credential source: {resolved.source.value}",
+            )
+        )
+        context.output().result(OutputDocument(kind="provider.whoami", data=data), human)

vidbyte_cli/commands/research/__init__.py

@@ -0,0 +1,5 @@
+"""Package marker for the `research` command namespace.
+
+Deliberately empty of re-exports: `commands/__init__.py` imports each command class from its
+own module, so adding a verb here never widens what a help path has to import.
+"""

vidbyte_cli/commands/research/add.py

@@ -0,0 +1,41 @@
+"""`vidbyte-cli research add <thread_id> <prompt>` — admit another run into an existing thread.
+
+The thread ID is the public share token `research start` and `research threads` print. It is
+checked locally first: the backend matches that path segment against a pattern before any
+lookup, so an internal identifier pasted from another tool fails as a bare validation error
+that explains nothing.
+"""
+
+from __future__ import annotations
+
+import click
+
+from ...lib.runtime.context import ApplicationContext
+from ...types.research import ThreadId
+from .options import ResearchRunOptions
+from .render import ResearchRenderer
+
+
+class ResearchAddCommand:
+    def register(self, parent: click.Group) -> None:
+        options = ResearchRunOptions()
+
+        def _run(context: ApplicationContext, /, **values: object) -> None:
+            self.execute(context, values)
+
+        callback = click.pass_obj(_run)
+        callback = click.argument("prompt")(callback)
+        callback = click.argument("thread_id")(callback)
+        parent.command(name="add", help="Add another prompt to an existing research thread")(
+            options.apply(callback)
+        )
+
+    def execute(self, context: ApplicationContext, values: dict[str, object]) -> None:
+        # The ID guard runs first so a mistyped thread never triggers a credential lookup.
+        thread_id = ThreadId.parse(str(values.get("thread_id", "")))
+        options = ResearchRunOptions()
+        request = options.build(values)
+        key = str(options.key(values))
+        accepted = context.research_endpoints().append_run(str(thread_id), request, key)
+        rendered = ResearchRenderer().accepted(accepted, key)
+        context.output().result(rendered.document, rendered.human)

vidbyte_cli/commands/research/options.py

@@ -0,0 +1,134 @@
+"""The request-shaping options `research start` and `research add` both accept.
+
+Declared once because the two commands submit the identical body to different routes, and a
+flag that drifted between them would be a silent behaviour difference nobody could see from
+either file.
+
+Only options the backend can act on are exposed. `source_sites` and `reference_artifact_ids`
+exist on the request DTO but need a catalogue and an artifact list the API-key surface does
+not publish, so a flag for either would accept values a caller has no way to discover.
+
+Click hands a callback its parameters as loose values, so the readers below are where those
+become typed: each one narrows a single option and the model rejects anything still wrong.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+import click
+
+from ...types.research import (
+    IdempotencyKey,
+    ResearchKind,
+    ResearchRunCreateRequest,
+    ResearchSize,
+)
+
+CommandCallback = Callable[..., None]
+OptionDecorator = Callable[[CommandCallback], CommandCallback]
+
+
+class ResearchRunOptions:
+    """Declares the shared run options and turns the parsed values into a request."""
+
+    def apply(self, callback: CommandCallback) -> CommandCallback:
+        # Click decorators apply bottom-up, so this reverses them to match the help listing.
+        for decorate in reversed(self._decorators()):
+            callback = decorate(callback)
+        return callback
+
+    def build(self, values: Mapping[str, object]) -> ResearchRunCreateRequest:
+        # Unset options stay None so the encoder omits them and the backend owns its defaults.
+        return ResearchRunCreateRequest(
+            prompt=self._prompt(values),
+            size=self._size(values),
+            target_sources=self._count(values, "target_sources"),
+            search_calls=self._count(values, "search_calls"),
+            resource_kinds=self._kinds(values),
+            include_domains=self._many(values, "include_domain"),
+            exclude_domains=self._many(values, "exclude_domain"),
+            published_after=self._text(values, "published_after"),
+            language=self._text(values, "language"),
+            max_run_cost_cents=self._count(values, "max_cost_cents"),
+        )
+
+    def key(self, values: Mapping[str, object]) -> IdempotencyKey:
+        # Validated before the request is built, so a bad key never reaches the network.
+        return IdempotencyKey.create(self._text(values, "idempotency_key"))
+
+    def _decorators(self) -> tuple[OptionDecorator, ...]:
+        return (
+            click.option(
+                "--size",
+                type=click.Choice([item.value for item in ResearchSize]),
+                help="Preset run breadth, when not sizing the run by hand.",
+            ),
+            click.option(
+                "--target-sources",
+                type=click.IntRange(1, 1_000),
+                help="How many sources discovery should aim to collect.",
+            ),
+            click.option(
+                "--search-calls",
+                type=click.IntRange(1, 100),
+                help="Upper bound on provider search calls for this run.",
+            ),
+            click.option(
+                "--kind",
+                multiple=True,
+                type=click.Choice([item.value for item in ResearchKind]),
+                help="Restrict discovery to this resource kind. Repeatable.",
+            ),
+            click.option(
+                "--include-domain",
+                multiple=True,
+                help="Restrict discovery to this hostname. Repeatable.",
+            ),
+            click.option(
+                "--exclude-domain",
+                multiple=True,
+                help="Exclude this hostname from discovery. Repeatable.",
+            ),
+            click.option(
+                "--published-after",
+                help="Only consider sources published on or after this YYYY-MM-DD date.",
+            ),
+            click.option("--language", help="Preferred source language tag, such as 'en'."),
+            click.option(
+                "--max-cost-cents",
+                type=click.IntRange(1, 100_000),
+                help="Refuse the run if it would cost more than this many cents.",
+            ),
+            click.option(
+                "--idempotency-key",
+                help="Reuse a key to retry a priced mutation without being charged twice.",
+            ),
+        )
+
+    def _prompt(self, values: Mapping[str, object]) -> str:
+        # A required Click argument is always present; the model rejects a blank one.
+        return str(values.get("prompt", ""))
+
+    def _text(self, values: Mapping[str, object], name: str) -> str | None:
+        value = values.get(name)
+        return str(value) if isinstance(value, str) and value else None
+
+    def _count(self, values: Mapping[str, object], name: str) -> int | None:
+        value = values.get(name)
+        return value if isinstance(value, int) else None
+
+    def _many(self, values: Mapping[str, object], name: str) -> list[str] | None:
+        # A repeatable option arrives as an empty tuple when unused, which must stay absent.
+        value = values.get(name)
+        if not isinstance(value, tuple) or not value:
+            return None
+        return [str(item) for item in value]
+
+    def _size(self, values: Mapping[str, object]) -> ResearchSize | None:
+        value = self._text(values, "size")
+        return ResearchSize(value) if value is not None else None
+
+    def _kinds(self, values: Mapping[str, object]) -> list[ResearchKind] | None:
+        value = self._many(values, "kind")
+        return [ResearchKind(item) for item in value] if value is not None else None

vidbyte_cli/commands/research/render.py

@@ -0,0 +1,157 @@
+"""Human text and machine documents for every research result shape.
+
+Both encodings are produced together so they cannot drift: a field added to the JSON without
+a line in the human block is the failure mode this file exists to prevent.
+
+The only thread identifier that appears anywhere here is `thread_id`, which the models bound
+to the API's public share token. The backend's internal identifier never reaches this layer,
+so no rendered line can offer a value a user would be unable to paste back.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pydantic import JsonValue
+
+from ...lib.output import OutputDocument
+from ...types.research import (
+    ResearchPortfolioPage,
+    ResearchRunAccepted,
+    ResearchRunStatus,
+    ResearchThreadDetail,
+    ResearchThreadSummary,
+)
+
+
+@dataclass(frozen=True)
+class RenderedResult:
+    """One result in both encodings the output manager may be asked for."""
+
+    document: OutputDocument
+    human: str
+
+
+class ResearchRenderer:
+    """Presentation for the four shapes the research surface returns."""
+
+    def accepted(self, accepted: ResearchRunAccepted, idempotency_key: str) -> RenderedResult:
+        # Admission: the two identifiers the caller needs for every follow-up command.
+        data: dict[str, JsonValue] = {
+            "thread_id": accepted.thread_id,
+            "run_id": accepted.run_id,
+            "status": accepted.status.value,
+            "idempotency_key": idempotency_key,
+        }
+        human = "\n".join(
+            (
+                f"Thread:  {accepted.thread_id}",
+                f"Run:     {accepted.run_id}",
+                f"Status:  {accepted.status.value}",
+                "",
+                f"Watch it:    vidbyte-cli research watch {accepted.run_id}",
+                f'Add to it:   vidbyte-cli research add {accepted.thread_id} "..."',
+            )
+        )
+        return RenderedResult(OutputDocument(kind="research.run_accepted", data=data), human)
+
+    def run_status(self, run: ResearchRunStatus) -> RenderedResult:
+        # One run's coarse progress. The status route publishes no live counters.
+        data: dict[str, JsonValue] = {
+            "run_id": run.run_id,
+            "status": run.status.value,
+            "phase": run.phase,
+            "continuation_count": run.continuation_count,
+            "updated_at": run.updated_at.isoformat(),
+            "terminal": run.status.is_terminal(),
+            # Published so an agent can branch on it without reimplementing the rule that
+            # a continuation is legal only from partial, failed, or credit-exhausted.
+            "resumable": run.status.is_resumable(),
+        }
+        lines = [
+            f"Run:       {run.run_id}",
+            f"Status:    {run.status.value}",
+            f"Phase:     {run.phase}",
+            f"Continued: {run.continuation_count}",
+            f"Updated:   {run.updated_at.isoformat()}",
+        ]
+        lines.extend(self._next_step(run))
+        document = OutputDocument(kind="research.run_status", data=data)
+        return RenderedResult(document, "\n".join(lines))
+
+    def _next_step(self, run: ResearchRunStatus) -> list[str]:
+        # A settled run is exactly where a caller needs the next command spelled out, and
+        # resuming is legal only from the three states `is_resumable` names.
+        if run.status.is_resumable():
+            return ["", f"Resume it:  vidbyte-cli research resume {run.run_id}"]
+        if run.status.is_terminal():
+            return []
+        return ["", f"Watch it:   vidbyte-cli research watch {run.run_id}"]
+
+    def transition(self, run: ResearchRunStatus) -> RenderedResult:
+        # A progress line during watch; the same record, marked as not-yet-final.
+        rendered = self.run_status(run)
+        document = OutputDocument(kind="research.run_transition", data=rendered.document.data)
+        return RenderedResult(document, f"{run.status.value} - {run.phase}")
+
+    def thread(self, thread: ResearchThreadDetail) -> RenderedResult:
+        # One thread read on its own, including the two fields a portfolio row omits.
+        data = self._thread_fields(thread)
+        data["latest_run_phase"] = thread.latest_run_phase
+        data["favorite"] = thread.favorite
+        human = "\n".join(
+            (
+                f"Thread:    {thread.thread_id}",
+                f"Title:     {thread.title}",
+                f"Runs:      {thread.run_count}",
+                f"Sources:   {thread.source_count}",
+                f"Artifacts: {thread.artifact_count}",
+                f"Latest:    {self._latest(thread)}",
+                f"Updated:   {thread.updated_at.isoformat()}",
+            )
+        )
+        return RenderedResult(OutputDocument(kind="research.thread", data=data), human)
+
+    def thread_page(self, page: ResearchPortfolioPage) -> RenderedResult:
+        # One page of threads, plus the cursor that continues it when there is more.
+        rows: list[JsonValue] = [self._thread_fields(thread) for thread in page.threads]
+        data: dict[str, JsonValue] = {"threads": rows, "next_cursor": page.next_cursor}
+        return RenderedResult(
+            OutputDocument(kind="research.threads", data=data),
+            self._thread_page_text(page),
+        )
+
+    def _thread_page_text(self, page: ResearchPortfolioPage) -> str:
+        if not page.threads:
+            return "No research threads."
+        width = max(len(thread.thread_id) for thread in page.threads)
+        lines = [
+            f"{thread.thread_id.ljust(width)}  {thread.run_count:>4} runs  {thread.title}"
+            for thread in page.threads
+        ]
+        if page.next_cursor is not None:
+            lines.append("")
+            lines.append(f"More available: --cursor {page.next_cursor}")
+        return "\n".join(lines)
+
+    def _thread_fields(self, thread: ResearchThreadSummary) -> dict[str, JsonValue]:
+        # The row shape shared by the portfolio page and the single-thread read.
+        status = thread.latest_run_status
+        return {
+            "thread_id": thread.thread_id,
+            "title": thread.title,
+            "run_count": thread.run_count,
+            "source_count": thread.source_count,
+            "artifact_count": thread.artifact_count,
+            "latest_run_id": thread.latest_run_id,
+            "latest_run_status": status.value if status is not None else None,
+            "created_at": thread.created_at.isoformat(),
+            "updated_at": thread.updated_at.isoformat(),
+        }
+
+    def _latest(self, thread: ResearchThreadSummary) -> str:
+        # A thread whose runs were all deleted still reads, so both fields may be absent.
+        if thread.latest_run_id is None:
+            return "no runs"
+        status = thread.latest_run_status
+        return f"{thread.latest_run_id} ({status.value if status is not None else 'unknown'})"

vidbyte_cli/commands/research/resume.py

@@ -0,0 +1,37 @@
+"""`vidbyte-cli research resume <run_id>` — continue a run that already settled badly.
+
+The backend accepts a continuation only from `partial`, `failed`, or `credit_exhausted`, and
+refuses every other state. That rule is enforced there rather than guessed at here: a status
+read before the attempt would be a second request whose answer could already be stale.
+
+There is no request body. A continuation replays the run's original prompt, so this command
+takes no run options — passing a new prompt would silently mean starting different work.
+"""
+
+from __future__ import annotations
+
+import click
+
+from ...lib.runtime.context import ApplicationContext
+from ...types.research import IdempotencyKey
+from .render import ResearchRenderer
+
+
+class ResearchResumeCommand:
+    def register(self, parent: click.Group) -> None:
+        @parent.command(name="resume", help="Continue a partial, failed, or out-of-credit run")
+        @click.argument("run_id")
+        @click.option(
+            "--idempotency-key",
+            help="Reuse a key to retry a priced mutation without being charged twice.",
+        )
+        @click.pass_obj
+        def _run(context: ApplicationContext, run_id: str, idempotency_key: str | None) -> None:
+            self.execute(context, run_id, idempotency_key)
+
+    def execute(self, context: ApplicationContext, run_id: str, explicit_key: str | None) -> None:
+        # Validates the key before resolving credentials, then admits the continuation.
+        key = str(IdempotencyKey.create(explicit_key))
+        accepted = context.research_endpoints().continue_run(run_id, key)
+        rendered = ResearchRenderer().accepted(accepted, key)
+        context.output().result(rendered.document, rendered.human)