quantnodes 3.0.0__py3-none-any.whl

QuantNodes/agent/cron_jobs.py

@@ -0,0 +1,314 @@
+# coding=utf-8
+"""QuantNodes-specific cron jobs.
+
+v3.0.0 Stage 5.5: Layer quant-domain periodic tasks on top of nanobot's
+upstream ``CronService``. We register three system jobs that run on a
+fixed schedule inside the in-process nanobot runtime:
+
+1. **Daily 16:30** (Asia/Shanghai) — ``quant-daily-recap``
+   Factor IC recalc + backtest result archival + a summary message
+   delivered to the configured channel (e.g. Feishu group chat).
+
+2. **Weekly Sunday 22:00** (Asia/Shanghai) — ``quant-weekly-review``
+   Factor performance report (IC / ICIR / decay) + risk attribution
+   summary across the live strategy pool.
+
+3. **Monthly 1st 02:00** (Asia/Shanghai) — ``quant-monthly-strategy-pool``
+   Wiki incremental index + strategy-pool monthly review (best/worst,
+   capacity check, deprecation candidates).
+
+All three are added via ``cron_service.add_job(...)`` so users can:
+
+- Inspect them with ``GET /api/agent/cron`` (planned, see
+  ``api/routers/agent.py``).
+- Disable / re-enable / delete them like any other job
+  (``CronService.remove_job`` refuses to remove ``system_event`` jobs,
+  but ours are ``agent_turn`` jobs and are user-removable).
+- Override the schedule / message via env vars (see
+  ``build_quant_cron_jobs_from_env`` below).
+
+We deliberately keep the **content** of each job a single concise message —
+the agent has the quant tools (``factor``, ``wiki``, ``strategy``,
+``backtest``) at its disposal and knows how to fan out into a proper
+report. This matches the upstream design: cron payloads are LLM
+prompts, not pre-baked Python scripts.
+
+Reference:
+
+- ``nanobot.cron.service.CronService`` — add_job / register_system_job
+- ``nanobot.cron.types.CronSchedule`` — kind: at | every | cron
+- ``nanobot.cron.types.CronPayload`` — kind: system_event | agent_turn
+- ``QuantNodes/agent/core/quant_dream.py`` — Dream hook (separate
+  periodic memory consolidation; not part of cron jobs)
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Callable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Default cron expressions in Asia/Shanghai (the team's working TZ).
+# Each entry pairs a job ``name`` with a default ``cron_expr`` and the
+# prompt template that the agent runs on each tick. Users override any
+# of these via env vars (see ``build_quant_cron_jobs_from_env``).
+DEFAULT_TZ = "Asia/Shanghai"
+
+
+@dataclass(frozen=True)
+class QuantCronJob:
+    """A quant-domain periodic task definition.
+
+    Fields mirror what ``CronService.add_job`` consumes (we keep the
+    declaration local to avoid an import cycle through nanobot at module
+    load time — the optional dep).
+    """
+
+    name: str
+    cron_expr: str
+    message: str
+    enabled: bool = True
+    deliver: bool = True
+    channel: Optional[str] = None
+    session_key: Optional[str] = None
+    description: str = ""
+
+
+# ----------------------------------------------------------------------------
+# Default job definitions
+# ----------------------------------------------------------------------------
+
+DAILY_RECAP_JOB = QuantCronJob(
+    name="quant-daily-recap",
+    cron_expr="30 16 * * 1-5",  # 16:30 Mon–Fri (skip weekends)
+    message=(
+        "执行日终复盘任务:\n"
+        "1. 调 factor 工具对核心因子池做今日 IC / ICIR 重算\n"
+        "2. 调 backtest 工具对今日有变动的策略跑一次回测，确认无过拟合 / "
+        "未来函数 / 手续费侵蚀\n"
+        "3. 调 wiki 工具把今日新增/变更的因子和策略写入 Wiki\n"
+        "4. 输出一段 ≤200 字的日终摘要（含因子表现 / 风险归因 / 明日关注点）"
+    ),
+    enabled=True,
+    deliver=True,
+    session_key="cron:quant-daily-recap",
+    description=(
+        "Daily 16:30 Mon-Fri — factor IC recalc + backtest archive + Wiki update."
+    ),
+)
+
+
+WEEKLY_REVIEW_JOB = QuantCronJob(
+    name="quant-weekly-review",
+    cron_expr="0 22 * * 0",  # 22:00 every Sunday
+    message=(
+        "执行周度复盘任务:\n"
+        "1. 调 factor 工具生成核心因子过去 5 个交易日的 IC / 衰减 / 换手率报告\n"
+        "2. 调 strategy 工具对策略池每个策略拉一次本周净值 / 风险归因\n"
+        "3. 调 wiki 工具把本周因子表现 / 策略表现 / 风险事件写入 Wiki 周报\n"
+        "4. 输出一段 ≤300 字的周度摘要（含因子池变化 / 策略池表现 / 风险事件）"
+    ),
+    enabled=True,
+    deliver=True,
+    session_key="cron:quant-weekly-review",
+    description=(
+        "Weekly Sunday 22:00 — factor performance report + risk attribution + Wiki weekly."
+    ),
+)
+
+
+MONTHLY_STRATEGY_POOL_JOB = QuantCronJob(
+    name="quant-monthly-strategy-pool",
+    cron_expr="0 2 1 * *",  # 02:00 on the 1st of every month
+    message=(
+        "执行月度策略池评审任务:\n"
+        "1. 调 wiki 工具做 Wiki 增量索引（核对因子 / 策略 / 回测报告三类文档数量与覆盖率）\n"
+        "2. 调 strategy 工具对策略池每个策略做月度表现 / 容量 / 衰减评估\n"
+        "3. 识别本月的 top-3 / bottom-3 策略，列出待下线 / 待重构的策略\n"
+        "4. 调 wiki 工具把评审结论写入 Wiki 的 strategy_review.md\n"
+        "5. 输出一段 ≤400 字的月度摘要（含策略池变化 / 新增下线 / 容量评估）"
+    ),
+    enabled=True,
+    deliver=True,
+    session_key="cron:quant-monthly-strategy-pool",
+    description=(
+        "Monthly 1st 02:00 — Wiki incremental + strategy-pool monthly review."
+    ),
+)
+
+
+DEFAULT_QUANT_CRON_JOBS: List[QuantCronJob] = [
+    DAILY_RECAP_JOB,
+    WEEKLY_REVIEW_JOB,
+    MONTHLY_STRATEGY_POOL_JOB,
+]
+
+
+# ----------------------------------------------------------------------------
+# Env-var overrides
+# ----------------------------------------------------------------------------
+
+# Each env var follows the pattern ``QUANTNODES__CRON__<NAME>__<FIELD>`` where
+# ``<NAME>`` is uppercased job name and ``<FIELD>`` is one of:
+#   - ENABLED       (bool: "1"/"true"/"false")
+#   - CRON_EXPR     (cron expression override)
+#   - MESSAGE       (full message override)
+#   - DELIVER       (bool: "1"/"true"/"false")
+#   - CHANNEL       (channel name override; e.g. "feishu")
+#
+# Example:
+#   QUANTNODES__CRON__QUANT_DAILY_RECAP__ENABLED=false
+#   QUANTNODES__CRON__QUANT_WEEKLY_REVIEW__CRON_EXPR="0 20 * * 0"
+
+
+def _env_flag(name: str, default: bool) -> bool:
+    raw = os.environ.get(name, "").strip().lower()
+    if not raw:
+        return default
+    return raw in ("1", "true", "yes", "on")
+
+
+def _apply_env_overrides(jobs: List[QuantCronJob]) -> List[QuantCronJob]:
+    """Apply per-job env-var overrides to a copy of ``jobs``.
+
+    Non-destructive: returns new ``QuantCronJob`` instances. Unknown env
+    vars are ignored. To disable a job, set its ``ENABLED=false`` env var.
+    """
+    overridden: List[QuantCronJob] = []
+    for job in jobs:
+        prefix = f"QUANTNODES__CRON__{job.name.replace('-', '_').upper()}__"
+        new_enabled = _env_flag(prefix + "ENABLED", job.enabled)
+        new_deliver = _env_flag(prefix + "DELIVER", job.deliver)
+        new_cron = os.environ.get(prefix + "CRON_EXPR", job.cron_expr).strip() or job.cron_expr
+        new_msg = os.environ.get(prefix + "MESSAGE", job.message) or job.message
+        new_chan = os.environ.get(prefix + "CHANNEL", job.channel or "") or job.channel
+
+        if (
+            new_enabled == job.enabled
+            and new_deliver == job.deliver
+            and new_cron == job.cron_expr
+            and new_msg == job.message
+            and new_chan == job.channel
+        ):
+            overridden.append(job)
+        else:
+            overridden.append(
+                QuantCronJob(
+                    name=job.name,
+                    cron_expr=new_cron,
+                    message=new_msg,
+                    enabled=new_enabled,
+                    deliver=new_deliver,
+                    channel=new_chan,
+                    session_key=job.session_key,
+                    description=job.description,
+                )
+            )
+    return overridden
+
+
+def build_quant_cron_jobs_from_env(
+    base_jobs: Optional[List[QuantCronJob]] = None,
+) -> List[QuantCronJob]:
+    """Return the default list of quant cron jobs, with env-var overrides.
+
+    Always returns a fresh list (safe to mutate). Filters out jobs that
+    the user has explicitly disabled via env (``ENABLED=false``).
+    """
+    base = list(base_jobs or DEFAULT_QUANT_CRON_JOBS)
+    merged = _apply_env_overrides(base)
+    enabled = [j for j in merged if j.enabled]
+    if len(enabled) != len(merged):
+        logger.info(
+            "build_quant_cron_jobs_from_env: disabled %d cron job(s) via env: %s",
+            len(merged) - len(enabled),
+            ", ".join(j.name for j in merged if not j.enabled),
+        )
+    return enabled
+
+
+# ----------------------------------------------------------------------------
+# Registration helper
+# ----------------------------------------------------------------------------
+
+def register_quant_cron_jobs(cron_service: Any) -> List[str]:
+    """Register all enabled quant cron jobs on a nanobot ``CronService``.
+
+    ``cron_service`` is expected to be a ``nanobot.cron.service.CronService``
+    instance. We use ``register_system_job`` (idempotent on restart) so
+    that on every process restart the jobs are re-registered without
+    duplicating. ``system_event`` is the right payload kind for our
+    internal quant jobs — they cannot be removed via the public
+    ``remove_job`` API and they survive config edits.
+
+    Returns the list of registered job IDs in the order they were added.
+
+    Lazy import of ``nanobot.cron.types`` to keep this module importable
+    even when ``nanobot-ai`` is not installed (the optional dep).
+    """
+    try:
+        from nanobot.cron.types import (
+            CronJob,
+            CronJobState,
+            CronPayload,
+            CronSchedule,
+        )
+    except ImportError as e:  # pragma: no cover - exercised in [agent] installs
+        raise NanobotNotInstalledForCron(str(e)) from e
+
+    jobs = build_quant_cron_jobs_from_env()
+    registered: List[str] = []
+    for job in jobs:
+        cron_job = CronJob(
+            id=f"quant-{job.name}",  # deterministic id for idempotency
+            name=job.name,
+            enabled=job.enabled,
+            schedule=CronSchedule(
+                kind="cron",
+                expr=job.cron_expr,
+                tz=DEFAULT_TZ,
+            ),
+            payload=CronPayload(
+                kind="system_event",
+                message=job.message,
+                deliver=job.deliver,
+                channel=job.channel,
+                session_key=job.session_key,
+            ),
+            state=CronJobState(),
+        )
+        cron_service.register_system_job(cron_job)
+        registered.append(cron_job.id)
+        logger.info(
+            "Registered quant cron job '%s' (cron='%s', tz=%s)",
+            cron_job.name,
+            job.cron_expr,
+            DEFAULT_TZ,
+        )
+    return registered
+
+
+class NanobotNotInstalledForCron(ImportError):
+    """Raised when ``register_quant_cron_jobs`` is called without nanobot.
+
+    Subclasses ``ImportError`` so callers (e.g. ``NanobotRuntime._build_components``)
+    can either catch it as ``ImportError`` for graceful degradation or as
+    the specific subclass for a clearer error message.
+    """
+
+
+__all__ = [
+    "DEFAULT_TZ",
+    "QuantCronJob",
+    "DAILY_RECAP_JOB",
+    "WEEKLY_REVIEW_JOB",
+    "MONTHLY_STRATEGY_POOL_JOB",
+    "DEFAULT_QUANT_CRON_JOBS",
+    "build_quant_cron_jobs_from_env",
+    "register_quant_cron_jobs",
+    "NanobotNotInstalledForCron",
+]

QuantNodes/agent/nanobot_bridge.py

@@ -0,0 +1,242 @@
+# coding=utf-8
+"""Agent facade wrapping HKUDS nanobot 0.2.1 (Path A: direct upstream consumption).
+
+Usage (backward-compatible v2.x signature):
+
+    from QuantNodes.agent import Agent
+    agent = Agent(workspace=".agent", config={...})
+    result = await agent.run("hello", session_id="default")
+
+Under the hood, Agent constructs a ``Nanobot`` from
+``.agent/nanobot_config.json`` (generated from ``.env`` by
+``config_mapper.py``), injects all 15 quant tools into its ToolRegistry,
+and exposes a thin compatibility layer for the streaming event protocol
+that the API layer (api/services/agent_service.py) expects.
+
+Reference: docs/13-Agent架构设计.md (v3.0.0) and docs/14-上游nanobot升级指南.md.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+# v3.0.0 Stage 5.3: nanobot-ai is now an optional dep. We delay the import
+# until ``Agent.__init__`` is called so that ``from QuantNodes.agent import
+# Agent`` works even when the [agent] extra is not installed (the import path
+# returns a proxy that raises ``NanobotNotInstalled`` on actual use).
+try:
+    from nanobot import Nanobot  # type: ignore[import-not-found]
+    from nanobot.agent.tools.base import Tool  # type: ignore[import-not-found]
+    from nanobot.agent.tools.registry import ToolRegistry  # type: ignore[import-not-found]
+    _NANOBOT_OK = True
+except ImportError:  # pragma: no cover - exercised in nanobot-less envs
+    Nanobot = None  # type: ignore[assignment,misc]
+    Tool = None  # type: ignore[assignment,misc]
+    ToolRegistry = None  # type: ignore[assignment,misc]
+    _NANOBOT_OK = False
+
+from .config_mapper import build_nanobot_config, write_nanobot_config
+from .tools import register_all_quant_tools
+
+logger = logging.getLogger(__name__)
+
+
+class Agent:
+    """Thin wrapper around HKUDS nanobot's ``Nanobot`` programmatic facade.
+
+    See nanobot_bridge.py module docstring for the full design rationale.
+    """
+
+    DEFAULT_WORKSPACE = ".agent"
+
+    def __init__(
+        self,
+        workspace: str = DEFAULT_WORKSPACE,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        if not _NANOBOT_OK:
+            from . import NanobotNotInstalled
+            raise NanobotNotInstalled("Agent")
+        config = config or {}
+        self.workspace = Path(workspace).expanduser().resolve()
+        self.workspace.mkdir(parents=True, exist_ok=True)
+
+        settings = build_nanobot_config(self.workspace, config)
+        self.config_path = write_nanobot_config(self.workspace, settings)
+
+        self._bot: Nanobot = Nanobot.from_config(self.config_path, workspace=self.workspace)
+        self._loop = self._bot._loop
+        self._hook_lock = asyncio.Lock()
+
+        quant_count = register_all_quant_tools(
+            self._loop.tools,
+            workspace=self.workspace,
+            llm_client=getattr(self._loop, 'provider', None),
+            model=getattr(self._loop, 'model', None),
+        )
+        logger.info(
+            "QuantNodes Agent ready (workspace=%s, quant_tools=%d, "
+            "upstream_tools=%d)",
+            self.workspace,
+            quant_count,
+            len(self._loop.tools._tools) - quant_count,
+        )
+
+    @property
+    def loop(self):
+        """Backward-compatible access to underlying AgentLoop."""
+        return self._loop
+
+    async def run(self, prompt: str, session_id: str = "default") -> str:
+        """Single-turn run returning the assistant's final text content."""
+        result = await self._bot.run(prompt, session_key=session_id)
+        return result.content or ""
+
+    async def chat(
+        self,
+        message: str,
+        session_id: str = "default",
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        mode: Optional[str] = None,
+        tools: Optional[List[str]] = None,
+        tool_choice: Optional[str] = None,
+        temperature: Optional[float] = None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """Stream chat events using the v2.x event protocol.
+
+        Emits dicts with shape::
+
+            {"type": "token", "content": str}
+            {"type": "tool_call", "id": str, "name": str, "arguments": dict}
+            {"type": "tool_result", "id": str, "name": str, "content": Any, "success": bool}
+            {"type": "done", "content": str, "tools_used": list[str], "stop_reason": str}
+            {"type": "error", "content": str}
+
+        Args:
+            tools: 工具名列表 (None=全部, []=无工具)
+            tool_choice: "auto"/"none"/"required"
+            temperature: 采样温度（可选）
+        """
+        from nanobot.agent.hook import SDKCaptureHook
+
+        capture = SDKCaptureHook()
+        async with self._hook_lock:
+            prev = self._loop._extra_hooks or []
+            self._loop._extra_hooks = [capture, *prev]
+        try:
+            async for event in self._stream_via_loop(
+                message, session_id, model, max_tokens, mode,
+                tools=tools, tool_choice=tool_choice, temperature=temperature,
+            ):
+                yield event
+        finally:
+            async with self._hook_lock:
+                self._loop._extra_hooks = prev
+
+    def _filter_tools(self, tool_names: Optional[List[str]]) -> ToolRegistry:
+        """过滤 nanobot 工具集。
+
+        Args:
+            tool_names: 工具名列表 (None=全部, []=无工具)
+
+        Returns:
+            ToolRegistry (可能是子集)
+        """
+        if tool_names is None:
+            return self._loop.tools
+
+        all_names = set(self._loop.tools._tools.keys())
+        valid = [n for n in tool_names if n in all_names]
+        invalid = [n for n in tool_names if n not in all_names]
+        if invalid:
+            logger.warning("LLMGateway: unknown tools filtered: %s", invalid)
+
+        sub = ToolRegistry()
+        for name in valid:
+            sub.register(self._loop.tools._tools[name])
+        return sub
+
+    async def _stream_via_loop(
+        self,
+        message: str,
+        session_id: str,
+        model: Optional[str],
+        max_tokens: Optional[int],
+        mode: Optional[str],
+        tools: Optional[List[str]] = None,
+        tool_choice: Optional[str] = None,
+        temperature: Optional[float] = None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """Drive the upstream AgentLoop and re-emit events in v2.x protocol."""
+        from nanobot.agent.runner import AgentRunSpec
+
+        filtered = self._filter_tools(tools)
+        spec = AgentRunSpec(
+            initial_messages=[{"role": "user", "content": message}],
+            tools=filtered,
+            model=model or getattr(self._loop, "model", None),
+            max_tokens=max_tokens or 16384,
+            max_iterations=getattr(self._loop, "max_iterations", 5),
+            max_tool_result_chars=getattr(self._loop, "max_tool_result_chars", 50000),
+            temperature=temperature,
+        )
+
+        tools_used: List[str] = []
+        final_content = ""
+        try:
+            async for event in self._loop.run_stream(spec):
+                etype = event.get("type")
+                if etype == "token":
+                    yield {"type": "token", "content": event.get("content", "")}
+                elif etype == "tool_call":
+                    name = event.get("name") or event.get("tool", "")
+                    if name:
+                        tools_used.append(name)
+                    yield {
+                        "type": "tool_call",
+                        "id": event.get("id", ""),
+                        "name": name,
+                        "arguments": event.get("arguments", {}),
+                    }
+                elif etype == "tool_result":
+                    yield {
+                        "type": "tool_result",
+                        "id": event.get("id", ""),
+                        "name": event.get("name", ""),
+                        "content": event.get("content"),
+                        "success": event.get("success", True),
+                    }
+                elif etype == "done":
+                    final_content = event.get("content", "") or final_content
+                    yield {
+                        "type": "done",
+                        "content": final_content,
+                        "tools_used": list(dict.fromkeys(tools_used)),
+                        "stop_reason": event.get("stop_reason", "stop"),
+                    }
+                elif etype == "error":
+                    yield {"type": "error", "content": event.get("content", "")}
+                elif etype == "message":
+                    delta = event.get("content")
+                    if delta:
+                        final_content += delta
+        except AttributeError:
+            result = await self._loop.process_direct(message, session_key=session_id)
+            yield {
+                "type": "done",
+                "content": getattr(result, "content", "") or "",
+                "tools_used": tools_used,
+                "stop_reason": getattr(result, "stop_reason", "stop") or "stop",
+            }
+        except Exception as exc:
+            logger.exception("Agent chat failed")
+            yield {"type": "error", "content": str(exc)}
+
+
+__all__ = ["Agent"]

QuantNodes/agent/permission/__init__.py

@@ -0,0 +1,30 @@
+# coding=utf-8
+"""
+权限系统模块
+"""
+
+from .models import (
+    Action,
+    PermissionRule,
+    PermissionRequest,
+    PermissionReply,
+    Ruleset,
+    PermissionDeniedError,
+    PermissionRejectedError,
+)
+from .evaluate import evaluate
+from .service import PermissionService
+from .defaults import create_default_ruleset
+
+__all__ = [
+    "Action",
+    "PermissionRule",
+    "PermissionRequest",
+    "PermissionReply",
+    "Ruleset",
+    "PermissionDeniedError",
+    "PermissionRejectedError",
+    "evaluate",
+    "PermissionService",
+    "create_default_ruleset",
+]

QuantNodes/agent/permission/defaults.py

@@ -0,0 +1,36 @@
+# coding=utf-8
+"""
+默认权限规则集
+"""
+
+from pathlib import Path
+from .models import PermissionRule, Action
+
+
+def create_default_ruleset(project_root: str | Path) -> list[PermissionRule]:
+    """创建默认权限规则集
+
+    安全原则：
+    1. 默认询问（安全默认）
+    2. 项目内文件读取允许
+    3. 敏感文件（.env）需要审批
+    4. 外部目录访问需要审批
+    5. shell 命令需要审批
+    """
+    project_root = Path(project_root)
+
+    return [
+        PermissionRule("*", "*", Action.ASK),
+        PermissionRule("read", "*", Action.ALLOW),
+        PermissionRule("read", "*.env", Action.ASK),
+        PermissionRule("read", "*.env.*", Action.ASK),
+        PermissionRule("read", ".env", Action.ASK),
+        PermissionRule("read", ".env.*", Action.ASK),
+        PermissionRule("read", "*.env.example", Action.ALLOW),
+        PermissionRule("edit", "*", Action.ALLOW),
+        PermissionRule("bash", "*", Action.ASK),
+        PermissionRule("external_directory", "*", Action.ASK),
+        PermissionRule("external_directory", "/tmp/*", Action.ALLOW),
+        PermissionRule("webfetch", "*", Action.ALLOW),
+        PermissionRule("websearch", "*", Action.ALLOW),
+    ]

QuantNodes/agent/permission/evaluate.py

@@ -0,0 +1,41 @@
+# coding=utf-8
+"""
+权限规则评估引擎
+"""
+
+from .models import PermissionRule, Action, Ruleset
+
+
+def evaluate(
+    permission: str,
+    target: str,
+    *rulesets: Ruleset,
+) -> PermissionRule:
+    """评估权限规则
+
+    规则评估逻辑：
+    1. 将所有 ruleset 扁平化
+    2. 从后向前查找第一个匹配的规则（后定义的规则优先）
+    3. 如果没有匹配规则，默认返回 ask（安全默认）
+
+    Args:
+        permission: 权限类别（如 "bash", "edit"）
+        target: 目标模式（如 "git commit", "/path/to/file.py"）
+        *rulesets: 规则集（按优先级从低到高排列）
+
+    Returns:
+        匹配的规则（包含 action）
+    """
+    all_rules = []
+    for rs in rulesets:
+        all_rules.extend(rs)
+
+    for rule in reversed(all_rules):
+        if rule.matches(permission, target):
+            return rule
+
+    return PermissionRule(
+        permission=permission,
+        pattern="*",
+        action=Action.ASK,
+    )