ltcai 5.2.0 → 5.4.0

package/lattice_brain/runtime/agent_runtime.py

@@ -1,5 +1,12 @@
 """AgentRuntime — the single boundary for agent execution and observability.
 
+(lattice_brain/runtime/agent_runtime.py)
+책임: 퍼사드. store/orchestrator/hooks/audit 주입 받아 start/reserve/complete,
+      status/health/config/events/replay/stop, pre/post_run hook firing.
+      RunExecutor와 /agents 라우터의 유일한 의존 대상.
+의존: .multi_agent (orchestrator), .hooks, store (WORKSPACE_OS).
+진입점: app_factory.py:AGENT_RUNTIME (wiring root), api/agents.py, RunExecutor.
+
 Before this module the agent concern was spread across three places: the
 :class:`~latticeai.core.multi_agent.MultiAgentOrchestrator` (role pipeline),
 the :class:`~latticeai.services.platform_runtime.PlatformRuntime` (cross-system

package/lattice_brain/runtime/hooks.py

@@ -1,5 +1,11 @@
 """Hooks platform — a persisted registry of lifecycle extension points.
 
+(lattice_brain/runtime/hooks.py)
+책임: HookContext/Result, HooksRegistry (persist+order+enable+builtin), dispatch_tool,
+      fire_hook (pre/post_run/tool/workflow), BUILTIN_HOOKS 등록.
+의존성: threading, subprocess (user hooks). dispatch_tool은 tool path 단일화.
+상위: agent_runtime.py (pre/post_run), tool_dispatch.py, api/tools, core/agent (shared).
+
 Lattice AI runs several behaviours at well-defined points in the agent / tool /
 workflow lifecycle (audit logging, secret redaction, sensitive-data
 classification, tool-permission gating, memory snapshots, workflow replay

package/lattice_brain/runtime/multi_agent.py

@@ -1,4 +1,9 @@
-"""Multi-Agent Runtime 2.1.
+"""Multi-Agent Runtime 2.1. (lattice_brain/runtime/multi_agent.py)
+
+책임: 역할 파이프라인 실행, handoff/context_packet/timeline/review/retry 기록 생성,
+      OrchestrationContext, default/llm_role_runner, MultiAgentOrchestrator.
+의존성: 없음 (순수). runner 주입으로 simulation vs llm 분리.
+상위 호출자: agent_runtime.py (orchestrator_factory), platform_runtime.
 
 The runtime remains a small, dependency-injected orchestrator, but v2.1 makes
 the operational objects first-class: handoffs, context packets, review/retry
@@ -14,7 +19,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "5.2.0"
+MULTI_AGENT_VERSION = "5.4.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "5.2.0"
+__version__ = "5.4.0"

package/latticeai/api/workflow_designer.py

@@ -51,6 +51,10 @@ class WorkflowImportRequest(BaseModel):
     data: Dict[str, Any] = {}
 
 
+class WorkflowRecipeInstallRequest(BaseModel):
+    enabled: bool = False
+
+
 def create_workflow_designer_router(
     *,
     store,
@@ -254,6 +258,62 @@ def create_workflow_designer_router(
             return {"running": False, "tick_seconds": None, "armed": []}
         return trigger_service.describe()
 
+    @router.get("/workflows/api/automation/recipes")
+    async def automation_recipes(request: Request):
+        require_user(request)
+        from latticeai.services.brain_automation import list_brain_automation_recipes
+
+        return list_brain_automation_recipes()
+
+    @router.post("/workflows/api/automation/recipes/{recipe_id}")
+    async def install_automation_recipe(recipe_id: str, req: WorkflowRecipeInstallRequest, request: Request):
+        current_user = require_user(request)
+        scope = gate_write(request)
+        from latticeai.services.brain_automation import (
+            build_brain_automation_workflow,
+            find_installed_recipe_workflow,
+        )
+
+        try:
+            definition = build_brain_automation_workflow(recipe_id, enabled=req.enabled)
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail=f"Automation recipe not found: {recipe_id}") from exc
+        existing = find_installed_recipe_workflow(
+            store.list_workflows(workspace_id=scope).get("workflows"), recipe_id
+        )
+        if existing is not None:
+            return {
+                "workflow": existing,
+                "recipe": existing.get("metadata") or definition["metadata"],
+                "enabled": bool((existing.get("metadata") or {}).get("automation_state") == "enabled"),
+                "already_installed": True,
+            }
+        errors = validate_definition({"name": definition["name"], "nodes": definition["nodes"]})
+        if errors:
+            raise HTTPException(status_code=400, detail={"validation_errors": errors})
+        workflow = store.create_workflow(
+            name=definition["name"],
+            steps=[{"action": n.get("type"), "node": n.get("id")} for n in definition["nodes"]],
+            nodes=definition["nodes"],
+            metadata=definition["metadata"],
+            user_email=current_user or None,
+            graph=workspace_graph(),
+            workspace_id=scope,
+        )
+        append_audit_event(
+            "brain_automation_recipe_installed",
+            user_email=current_user,
+            workflow_id=workflow["id"],
+            recipe_id=recipe_id,
+            enabled=bool(req.enabled),
+        )
+        return {
+            "workflow": workflow,
+            "recipe": definition["metadata"],
+            "enabled": bool(req.enabled),
+            "already_installed": False,
+        }
+
     @router.get("/workflows/api/runs/{run_id}/replay")
     async def workflow_run_replay(run_id: str, request: Request):
         require_user(request)

package/latticeai/app_factory.py

@@ -17,90 +17,16 @@ from __future__ import annotations
 import threading
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
+from latticeai.runtime.brain_runtime import build_brain_runtime
+from latticeai.runtime.config_runtime import build_config_runtime
+from latticeai.runtime.security_runtime import build_security_runtime
+
 if TYPE_CHECKING:  # imports for annotations only — keep module import light
     from fastapi import FastAPI
 
     from latticeai.core.config import Config
 
 
-def build_config_runtime(config: "Optional[Config]" = None) -> Dict[str, Any]:
-    """Build the app configuration runtime without importing heavy model code."""
-
-    from latticeai.core.config import Config
-
-    cfg = config if config is not None else Config.from_env()
-    return {
-        "CONFIG": cfg,
-        "APP_MODE": cfg.app_mode,
-        "IS_PUBLIC_MODE": cfg.is_public,
-        "DEFAULT_HOST": cfg.host,
-        "DEFAULT_PORT": cfg.port,
-        "NETWORK_EXPOSED": cfg.network_exposed,
-        "ENABLE_TELEGRAM": cfg.enable_telegram,
-        "ENABLE_GRAPH": cfg.enable_graph,
-        "AUTOLOAD_MODELS": cfg.autoload_models,
-        "MODEL_IDLE_UNLOAD_SECONDS": cfg.model_idle_unload_seconds,
-        "ALLOW_LOCAL_MODELS": cfg.allow_local_models,
-        "REQUIRE_AUTH": cfg.require_auth,
-        "ALLOW_PLAINTEXT_API_KEYS": cfg.allow_plaintext_api_keys,
-        "CORS_ALLOW_NETWORK": cfg.cors_allow_network,
-        "CORS_EXTRA_ORIGINS": cfg.cors_extra_origins,
-        "PUBLIC_MODEL": cfg.public_model,
-        "LOCAL_MODEL": cfg.local_model,
-        "LOCAL_DRAFT_MODEL": cfg.local_draft_model,
-    }
-
-
-def build_security_runtime(config: "Config") -> Dict[str, Any]:
-    """Build auth/security-derived runtime settings from the central config."""
-
-    from latticeai.core.security import configure_trusted_proxies
-
-    configure_trusted_proxies(config.trusted_proxies)
-    return {
-        "SSO_DISCOVERY_URL": config.sso_discovery_url,
-        "SSO_CLIENT_ID": config.sso_client_id,
-        "SSO_CLIENT_SECRET": config.sso_client_secret,
-        "SSO_REDIRECT_URI": config.sso_redirect_uri,
-        "SSO_PROVIDER_NAME": config.sso_provider_name,
-        "RATE_LIMIT_ENABLED": config.rate_limit_enabled,
-        "OPEN_REGISTRATION": config.open_registration,
-        "INVITE_CODE": config.invite_code,
-        "INVITE_GATE_ENABLED": config.invite_gate_enabled,
-    }
-
-
-def build_brain_runtime(
-    *,
-    data_dir: Any,
-    history_file: Any,
-    enable_graph: bool,
-    embedder: Any,
-    storage_engine: Any,
-) -> Dict[str, Any]:
-    """Construct Brain Core storage/conversation primitives behind one seam."""
-
-    from lattice_brain import BrainCore, ConversationStore
-
-    brain_core = BrainCore.from_paths(
-        data_dir,
-        embedder=embedder.provider,
-        storage_engine=storage_engine,
-    ) if enable_graph else None
-    knowledge_graph = brain_core.knowledge if brain_core is not None else None
-    conversations = (
-        brain_core.conversations
-        if brain_core is not None
-        else ConversationStore(data_dir / "knowledge_graph.sqlite")
-    )
-    conversations.import_legacy_json(history_file)
-    return {
-        "BRAIN_CORE": brain_core,
-        "KNOWLEDGE_GRAPH": knowledge_graph,
-        "CONVERSATIONS": conversations,
-    }
-
-
 def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     """The legacy ``server_app`` assembly, moved verbatim into function scope.
 
@@ -1579,6 +1505,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     HOOKS_REGISTRY.register_hook(_trigger_hook_id, TRIGGER_SERVICE.hook_runner())
 
     # Single AgentRuntime boundary over the orchestrator + run store.
+    # (lattice_brain/runtime.agent_runtime.AgentRuntime — see runtime/__init__.py for full dep graph + entry mapping)
     AGENT_RUNTIME = AgentRuntime(
         store=WORKSPACE_OS,
         orchestrator_factory=PLATFORM.build_orchestrator,

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "5.2.0"
+MARKETPLACE_VERSION = "5.4.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "5.2.0"
+WORKSPACE_OS_VERSION = "5.4.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/runtime/__init__.py

@@ -0,0 +1,2 @@
+"""Runtime assembly seams for the Lattice AI application factory."""
+

package/latticeai/runtime/brain_runtime.py

@@ -0,0 +1,41 @@
+"""Brain Core runtime assembly for app startup."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+
+def build_brain_runtime(
+    *,
+    data_dir: Any,
+    history_file: Any,
+    enable_graph: bool,
+    embedder: Any,
+    storage_engine: Any,
+) -> Dict[str, Any]:
+    """Construct Brain Core storage/conversation primitives behind one seam."""
+
+    from lattice_brain import BrainCore, ConversationStore
+
+    brain_core = (
+        BrainCore.from_paths(
+            data_dir,
+            embedder=embedder.provider,
+            storage_engine=storage_engine,
+        )
+        if enable_graph
+        else None
+    )
+    knowledge_graph = brain_core.knowledge if brain_core is not None else None
+    conversations = (
+        brain_core.conversations
+        if brain_core is not None
+        else ConversationStore(data_dir / "knowledge_graph.sqlite")
+    )
+    conversations.import_legacy_json(history_file)
+    return {
+        "BRAIN_CORE": brain_core,
+        "KNOWLEDGE_GRAPH": knowledge_graph,
+        "CONVERSATIONS": conversations,
+    }
+

package/latticeai/runtime/config_runtime.py

@@ -0,0 +1,36 @@
+"""Configuration runtime assembly for the FastAPI composition root."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:
+    from latticeai.core.config import Config
+
+
+def build_config_runtime(config: "Optional[Config]" = None) -> Dict[str, Any]:
+    """Build app configuration values without importing model/runtime code."""
+
+    from latticeai.core.config import Config
+
+    cfg = config if config is not None else Config.from_env()
+    return {
+        "CONFIG": cfg,
+        "APP_MODE": cfg.app_mode,
+        "IS_PUBLIC_MODE": cfg.is_public,
+        "DEFAULT_HOST": cfg.host,
+        "DEFAULT_PORT": cfg.port,
+        "NETWORK_EXPOSED": cfg.network_exposed,
+        "ENABLE_TELEGRAM": cfg.enable_telegram,
+        "ENABLE_GRAPH": cfg.enable_graph,
+        "AUTOLOAD_MODELS": cfg.autoload_models,
+        "MODEL_IDLE_UNLOAD_SECONDS": cfg.model_idle_unload_seconds,
+        "ALLOW_LOCAL_MODELS": cfg.allow_local_models,
+        "REQUIRE_AUTH": cfg.require_auth,
+        "ALLOW_PLAINTEXT_API_KEYS": cfg.allow_plaintext_api_keys,
+        "CORS_ALLOW_NETWORK": cfg.cors_allow_network,
+        "CORS_EXTRA_ORIGINS": cfg.cors_extra_origins,
+        "PUBLIC_MODEL": cfg.public_model,
+        "LOCAL_MODEL": cfg.local_model,
+        "LOCAL_DRAFT_MODEL": cfg.local_draft_model,
+    }

package/latticeai/runtime/security_runtime.py

@@ -0,0 +1,27 @@
+"""Security runtime assembly for app startup."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+if TYPE_CHECKING:
+    from latticeai.core.config import Config
+
+
+def build_security_runtime(config: "Config") -> Dict[str, Any]:
+    """Build auth/security-derived runtime settings from the central config."""
+
+    from latticeai.core.security import configure_trusted_proxies
+
+    configure_trusted_proxies(config.trusted_proxies)
+    return {
+        "SSO_DISCOVERY_URL": config.sso_discovery_url,
+        "SSO_CLIENT_ID": config.sso_client_id,
+        "SSO_CLIENT_SECRET": config.sso_client_secret,
+        "SSO_REDIRECT_URI": config.sso_redirect_uri,
+        "SSO_PROVIDER_NAME": config.sso_provider_name,
+        "RATE_LIMIT_ENABLED": config.rate_limit_enabled,
+        "OPEN_REGISTRATION": config.open_registration,
+        "INVITE_CODE": config.invite_code,
+        "INVITE_GATE_ENABLED": config.invite_gate_enabled,
+    }

package/latticeai/services/brain_automation.py

@@ -0,0 +1,214 @@
+"""Consent-first Brain automation recipes.
+
+The recipes here are product-level starter workflows, not hidden background
+jobs. Installing one creates a disabled draft workflow so the user can inspect
+and enable it deliberately.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class BrainAutomationRecipe:
+    id: str
+    name: str
+    summary: str
+    user_value: str
+    cadence: str
+    trigger: Dict[str, Any]
+    prompt: str
+    creates: List[str]
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "summary": self.summary,
+            "user_value": self.user_value,
+            "cadence": self.cadence,
+            "trigger": deepcopy(self.trigger),
+            "creates": list(self.creates),
+            "consent": {
+                "default_state": "draft_disabled",
+                "local_only": True,
+                "external_actions": False,
+                "requires_user_enable": True,
+                "review_before_run": True,
+            },
+        }
+
+
+_RECIPES: List[BrainAutomationRecipe] = [
+    BrainAutomationRecipe(
+        id="daily-memory-digest",
+        name="Daily Memory Digest",
+        summary="Collects the day's new memories into a short review draft.",
+        user_value="Users see what the Brain kept today without searching through chats.",
+        cadence="daily",
+        trigger={"trigger": "interval", "interval_seconds": 86_400},
+        prompt=(
+            "Review today's new Brain memories and draft a concise digest with "
+            "important decisions, unresolved questions, and suggested next actions. "
+            "Do not contact external services."
+        ),
+        creates=["memory digest", "decision summary", "next-action suggestions"],
+    ),
+    BrainAutomationRecipe(
+        id="weekly-project-review",
+        name="Weekly Project Review",
+        summary="Turns project context into a weekly checkpoint draft.",
+        user_value="Users can restart a project without explaining the week again.",
+        cadence="weekly",
+        trigger={"trigger": "interval", "interval_seconds": 604_800},
+        prompt=(
+            "Review this workspace's recent memories, workflow runs, and decisions. "
+            "Draft a project checkpoint with progress, risks, blockers, and next steps. "
+            "Keep it local and ask before any external action."
+        ),
+        creates=["project checkpoint", "risk list", "next-week plan"],
+    ),
+    BrainAutomationRecipe(
+        id="follow-up-radar",
+        name="Follow-up Radar",
+        summary="Looks for follow-up candidates when new knowledge enters the Brain.",
+        user_value="Users get gentle reminders for loose ends without a noisy task system.",
+        cadence="when new memory is saved",
+        trigger={"trigger": "brain_event"},
+        prompt=(
+            "Inspect the new Brain memory for follow-up signals such as decisions, "
+            "promises, deadlines, unresolved questions, or 'later' language. "
+            "Return suggestions only; do not create tasks without approval."
+        ),
+        creates=["follow-up suggestions", "open-question list", "approval-ready task drafts"],
+    ),
+]
+
+_RECIPE_BY_ID = {recipe.id: recipe for recipe in _RECIPES}
+
+
+def list_brain_automation_recipes() -> Dict[str, Any]:
+    """Return user-facing, consent-first automation recipe metadata."""
+    return {
+        "recipes": [recipe.as_dict() for recipe in _RECIPES],
+        "principles": {
+            "local_first": True,
+            "drafts_before_automation": True,
+            "no_external_actions_without_consent": True,
+        },
+    }
+
+
+def find_installed_recipe_workflow(
+    workflows: Any, recipe_id: str
+) -> Dict[str, Any] | None:
+    """Return an existing draft installed from ``recipe_id``, if any.
+
+    Installing a recipe is idempotent: clicking "Create reviewable draft" twice
+    should surface the existing draft instead of accumulating duplicates. We
+    match on the ``brain_automation_recipe`` provenance metadata stamped by
+    :func:`build_brain_automation_workflow`.
+    """
+    for workflow in workflows or []:
+        metadata = (workflow or {}).get("metadata") or {}
+        if (
+            metadata.get("created_from") == "brain_automation_recipe"
+            and metadata.get("recipe_id") == recipe_id
+        ):
+            return workflow
+    return None
+
+
+def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) -> Dict[str, Any]:
+    """Build a workflow definition for a recipe.
+
+    ``enabled`` defaults to ``False`` so installing a recipe creates an
+    inspectable draft. The trigger service treats explicit ``enabled: false`` as
+    disarmed, while legacy workflows without the field keep their behavior.
+    """
+    recipe = _RECIPE_BY_ID.get(recipe_id)
+    if recipe is None:
+        raise KeyError(recipe_id)
+
+    trigger_config = {
+        **deepcopy(recipe.trigger),
+        "enabled": bool(enabled),
+        "consent_required": True,
+        "local_only": True,
+        "external_actions": False,
+    }
+    return {
+        "name": recipe.name,
+        "nodes": [
+            {
+                "id": "trigger",
+                "type": "trigger",
+                "name": "User-enabled schedule" if recipe.trigger["trigger"] == "interval" else "New Brain memory",
+                "config": trigger_config,
+                "next": "draft",
+            },
+            {
+                "id": "draft",
+                "type": "agent",
+                "name": "Draft Brain review",
+                "config": {
+                    "agent": "agent:planner",
+                    "prompt": recipe.prompt,
+                    "mode": "draft",
+                    "local_only": True,
+                    "external_actions": False,
+                    "requires_review": True,
+                },
+                "next": "output",
+            },
+            {
+                "id": "output",
+                "type": "output",
+                "name": "Review before saving",
+                "config": {
+                    "value": "Draft ready for review. Save, edit, or discard it before it becomes durable memory.",
+                },
+                "next": None,
+            },
+        ],
+        "metadata": {
+            "created_from": "brain_automation_recipe",
+            "recipe_id": recipe.id,
+            "recipe_summary": recipe.summary,
+            "recipe_user_value": recipe.user_value,
+            "automation_state": "enabled" if enabled else "draft_disabled",
+            "local_only": True,
+            "external_actions": False,
+            "requires_user_enable": not enabled,
+            "creates": list(recipe.creates),
+        },
+    }
+
+
+# === A방향 (Act/automation + BrainAutomationPanel) E2E 시나리오 초안 ===
+# (backend 인터페이스 list_brain_automation_recipes / find_installed... / build_... 완료 후 즉시 작성)
+# 1. Recipe 목록 노출: frontend BrainAutomationPanel이 list_brain_automation_recipes() 호출 → recipes + consent metadata 표시.
+# 2. "Create reviewable draft" 클릭:
+#    - build_brain_automation_workflow(recipe_id, enabled=False) 로 draft 생성 (metadata.recipe_id + created_from=brain_automation_recipe)
+#    - find_installed_recipe_workflow 로 사전 dedup 체크 → 이미 있으면 기존 반환, UI disabled + "✓ Reviewable draft ready" 피드백.
+#    - 생성된 workflow는 automation_state="draft_disabled", trigger.enabled=False → TriggerService 무시.
+# 3. Dedup guard (UI + backend): metadata.recipe_id + created_from 기준. 중복 클릭 가드 (no-dup) 로 double submit 방지.
+# 4. User가 draft를 review/수정 후 enabled=True 로 전환 → TriggerService._triggered_workflows 에서 enabled True인 것만 arm.
+# 5. Interval trigger E2E:
+#    - reconcile_missed() : 다운타임 중 missed → "skipped" 이벤트 기록 (catch-up storm 없음).
+#    - tick_intervals() : last_fired_at + interval + last_attempt_at dedup 가드 (10s cooldown) 로 중복 실행 방지.
+#    - LATTICE_TZ 환경변수: describe()에 "tz" 노출, 이벤트 at 값은 epoch이지만 클라이언트가 LATTICE_TZ로 현지화.
+# 6. Brain event trigger E2E: kg_ingest.* post_tool hook → on_brain_event → matching source_type 필터 → _fire (dedup 5s).
+# 7. Failure degraded:
+#    - _fire 에서 run_workflow 예외 → _record_fire_outcome → consecutive_failures++ , describe() "status":"degraded" ( >=3 ).
+#    - 성공 시 reset. (실행 내부 실패는 workflow run record에 남음, scheduler는 launch health만).
+# 8. Run provenance: fired run의 inputs["__trigger__"] = {"type": "interval"|"brain_event", ...} 로 감사/디버그 가능.
+# 9. Consent-first: draft_disabled 기본, user enable 전까지 절대 실행 안 됨. "review_before_run": True.
+# 10. End-to-end Act: draft → enable → trigger fire → agent:planner "Draft Brain review" 노드 → output (requires_review) → user review → save or discard.
+#
+# 다음: 실제 API (e.g. POST /brain/automation/install-draft) 가 UI에서 호출되면 위 시나리오에 대한 통합 테스트 + RunExecutor 경로 검증 즉시 추가.
+# 현재 상태: backend recipe 인터페이스 + TriggerService edge 하드닝 + AgentRuntime wiring 완료. UI (App.tsx + styles) + test_brain_automation.py 는 별도 완료 보고됨.
+

package/latticeai/services/model_capability_registry.py

@@ -20,9 +20,8 @@ are never auto-fetched by the verifier. Large models (>12GB) explicitly note
 
 from __future__ import annotations
 
-import datetime as _dt
-from dataclasses import dataclass, asdict, field
-from typing import Any, Dict, List, Optional, Tuple
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
 
 
 @dataclass(frozen=True)