ltcai 11.5.2 → 11.6.0

package/lattice_brain/multimodal/images.py

@@ -1,10 +1,10 @@
-"""A picture as a first-class memory: what was observed, and what was written.
+"""A picture as a first-class memory: what can be observed about one file.
 
-Two halves, in order: :func:`extract_image_facts` observes one file (size, OCR,
-caption, vector — each with its own status), and :func:`write_image_memory`
-turns those facts into an ``Image`` node with its chunks, concepts and source
-link. Video reuses both verbatim for its keyframes, which is why nothing here
-knows what a video is.
+:func:`extract_image_facts` observes one file — size, OCR, caption, vector, each
+with its own status — and answers with :class:`ImageFacts`. Turning those facts
+into an ``Image`` node with its chunks, concepts and source link was the other
+half of this module; ``lattice-core``'s graph write engine owns it since
+v11.6.0, and this side never learned what a node was anyway.
 """
 
 from __future__ import annotations
@@ -12,20 +12,14 @@ from __future__ import annotations
 import base64
 import io
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
 from ..quiet import quiet
-from ..utils import utc_now_iso
 from .common import (
     MAX_INDEX_TEXT_CHARS,
     MAX_THUMBNAIL_CHARS,
     MODALITY_IMAGE,
-    SUMMARY_CHARS,
     THUMBNAIL_EDGE,
-    _sha256_file,
-    _sha256_text,
-    _split_index_text,
 )
 from .ports import MultimodalPorts
 
@@ -244,255 +238,3 @@ def image_quality_score(facts: ImageFacts) -> Dict[str, Any]:
     return {"score": round(max(0.0, min(1.0, score)), 4), "reasons": reasons}
 
 
-def image_node_id(content_hash: str, workspace_id: Optional[str] = None) -> str:
-    """Workspace-scoped, content-addressed id — re-ingesting is idempotent."""
-    scoped = f"{workspace_id or 'legacy-global'}|{content_hash}"
-    return f"image:{_sha256_text(scoped)[:24]}"
-
-
-def write_image_memory(
-    store: Any,
-    *,
-    path: Path,
-    facts: ImageFacts,
-    title: str,
-    source_type: str = MODALITY_IMAGE,
-    source_uri: Optional[str] = None,
-    owner: Optional[str] = None,
-    workspace_id: Optional[str] = None,
-    conversation_id: Optional[str] = None,
-    captured_at: Optional[str] = None,
-    modified_at: Optional[str] = None,
-    permissions: Optional[Dict[str, Any]] = None,
-    extra_metadata: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """Write one ``Image`` node (plus ``ImageText``/chunks) into the graph.
-
-    The node is the image itself rather than a ``Document`` that happens to be
-    a picture, because that is what the rest of the product reasons about: the
-    graph already declares ``Image``/``ImageText``/``CONTAINS_IMAGE``, and
-    ``hybrid_search`` already ranks ``Image`` as a first-class result type.
-
-    Uses the same cross-mixin write door (``_upsert_node``/``_upsert_edge``/
-    ``_upsert_chunk``) that every other ingest path uses — the store exposes no
-    public node writer, and inventing a second one for images would be a
-    parallel write path to keep in sync forever.
-    """
-    captured_at = captured_at or utc_now_iso()
-    content_hash = _sha256_file(path)
-    node_id = image_node_id(content_hash, workspace_id)
-    index_text = facts.index_text()
-    metadata: Dict[str, Any] = {
-        "filename": path.name,
-        "file_path": str(path),
-        "ext": path.suffix.lower(),
-        "bytes": path.stat().st_size,
-        "sha256": content_hash,
-        "content_hash": content_hash,
-        "source_type": source_type,
-        "source_uri": source_uri or str(path),
-        "captured_at": captured_at,
-        "modified_at": modified_at,
-        "owner": owner,
-        "workspace_id": workspace_id,
-        "permissions": permissions or {},
-        "conversation_id": conversation_id,
-        **facts.as_metadata(),
-        **(extra_metadata or {}),
-    }
-    # Honest summary: when nothing could be read out of the picture, say so
-    # rather than leaving a blank card that looks like a failed render.
-    summary = index_text[:SUMMARY_CHARS] or f"[{MODALITY_IMAGE}] {path.name}"
-    chunk_ids: List[str] = []
-
-    with store._connect() as conn:
-        duplicate = (
-            conn.execute("SELECT 1 FROM nodes WHERE id=? LIMIT 1", (node_id,)).fetchone()
-            is not None
-        )
-        store._upsert_node(
-            conn,
-            node_id,
-            "Image",
-            title or path.name,
-            summary=summary,
-            metadata=metadata,
-            raw=metadata,
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-        if facts.ocr_text:
-            image_text_id = f"imagetext:{_sha256_text(f'{node_id}:ocr')[:24]}"
-            store._upsert_node(
-                conn,
-                image_text_id,
-                "ImageText",
-                f"{path.name} OCR",
-                summary=facts.ocr_text[:700],
-                metadata={
-                    "source_node": node_id,
-                    "chars": len(facts.ocr_text),
-                    "workspace_id": workspace_id,
-                },
-                owner=owner,
-                workspace_id=workspace_id,
-            )
-            store._upsert_edge(
-                conn,
-                node_id,
-                image_text_id,
-                "포함함",
-                weight=0.8,
-                metadata={"source": "ocr", "workspace_id": workspace_id},
-            )
-        for index, piece in enumerate(_split_index_text(index_text)):
-            chunk_id = f"chunk:{_sha256_text(f'{node_id}:{index}:{piece}')[:24]}"
-            chunk_ids.append(chunk_id)
-            chunk_meta = {
-                "index": index,
-                "source_node": node_id,
-                "workspace_id": workspace_id,
-                "modality": MODALITY_IMAGE,
-            }
-            store._upsert_node(
-                conn,
-                chunk_id,
-                "Chunk",
-                f"{path.name} chunk {index + 1}",
-                summary=piece[:SUMMARY_CHARS],
-                metadata=chunk_meta,
-                owner=owner,
-                workspace_id=workspace_id,
-            )
-            store._upsert_chunk(
-                conn,
-                chunk_id=chunk_id,
-                source_node=node_id,
-                text=piece,
-                metadata=chunk_meta,
-            )
-            store._upsert_edge(conn, node_id, chunk_id, "포함함")
-        # Concepts come from what is *in* the picture, never from its name:
-        # "IMG_2381" is not a topic, and turning filenames into concept nodes
-        # would fill the graph with hubs that mean nothing.
-        concept_ids = _attach_concepts(
-            store,
-            conn,
-            node_id=node_id,
-            text=index_text,
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-        source_node_id = _attach_source(
-            store,
-            conn,
-            node_id=node_id,
-            source_type=source_type,
-            source_uri=source_uri or str(path),
-            title=title or path.name,
-            content_hash=content_hash,
-            captured_at=captured_at,
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-    metadata["concepts"] = concept_ids
-    return {
-        "node_id": node_id,
-        "type": "Image",
-        "title": title or path.name,
-        "sha256": content_hash,
-        "content_hash": content_hash,
-        "source_node_id": source_node_id,
-        "chunk_ids": chunk_ids,
-        "chunk_count": len(chunk_ids),
-        "duplicate": duplicate,
-        "captured_at": captured_at,
-        "metadata": metadata,
-    }
-
-
-def _attach_concepts(
-    store: Any,
-    conn: Any,
-    *,
-    node_id: str,
-    text: str,
-    owner: Optional[str],
-    workspace_id: Optional[str],
-) -> List[str]:
-    """Pull concepts out of the caption/OCR so the picture joins the graph.
-
-    This is what "the caption contributes to the graph" means concretely: the
-    same extractor every text door uses, over the same text, producing the same
-    ``Concept``/``Feature``/… nodes and ``포함함`` edges — so a photo of a
-    whiteboard about Q3 planning is one hop from every note about Q3 planning,
-    instead of being an island that only exact search can reach.
-
-    An image with nothing readable in it yields no concepts, which is correct:
-    there is nothing to say about it.
-    """
-    body = str(text or "").strip()
-    if not body:
-        return []
-    from ..graph._kg_common import (  # local: keeps this module's import light
-        _classify_node_type,
-        _extract_concepts,
-    )
-
-    # The id derivation is imported rather than re-derived: two copies of a
-    # node-id rule diverge, and a diverged id is a duplicate concept nobody
-    # can see.
-    from ..graph.ingest import _scoped_slug_id
-
-    concept_ids: List[str] = []
-    for concept in _extract_concepts(body, limit=10):
-        node_type = _classify_node_type(concept, body)
-        concept_id = _scoped_slug_id(node_type.lower(), concept, workspace_id)
-        store._upsert_node(
-            conn,
-            concept_id,
-            node_type,
-            concept,
-            metadata={
-                "auto_extracted": True,
-                "source_node": node_id,
-                "modality": MODALITY_IMAGE,
-                "workspace_id": workspace_id,
-            },
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-        store._upsert_edge(conn, node_id, concept_id, "포함함", weight=0.8)
-        concept_ids.append(concept_id)
-    return concept_ids
-
-
-def _attach_source(
-    store: Any,
-    conn: Any,
-    *,
-    node_id: str,
-    source_type: str,
-    source_uri: str,
-    title: str,
-    content_hash: str,
-    captured_at: str,
-    owner: Optional[str],
-    workspace_id: Optional[str],
-) -> Optional[str]:
-    """Link the image to a ``Source`` node when the store can make one."""
-    attach = getattr(store, "_attach_source_node", None)
-    if not callable(attach):
-        return None
-    return str(
-        attach(
-            conn,
-            node_id,
-            source_type=source_type,
-            source_uri=source_uri,
-            title=title,
-            content_hash=content_hash,
-            captured_at=captured_at,
-            extra={"owner": owner, "workspace_id": workspace_id, "modality": MODALITY_IMAGE},
-        )
-    )

package/lattice_brain/multimodal/video.py

@@ -1,10 +1,11 @@
-"""A video as keyframes through the image door, plus its subtitles as text.
-
-Nothing here is a new retrieval path. The stills go through
-:func:`~lattice_brain.multimodal.images.write_image_memory` exactly as a
-photograph does, the subtitles become ordinary chunks, and what the ``Video``
-node adds is the thing they belong to. Keyframe *extraction* lives in
-``ports.py`` beside the decoder it falls back to; this module only consumes it.
+"""What can be read off a video file: its container facts and its subtitles.
+
+Writing the ``Video`` node, the keyframe stills and the edges between them is
+``lattice-core``'s since v11.6.0. What is left is the reading:
+:func:`read_video_facts` opens the container, :func:`find_subtitle` looks for
+the ``.srt``/``.vtt`` beside it and :func:`parse_subtitles` turns cues into
+plain text. Keyframe *extraction* lives in ``ports.py`` beside the decoder it
+falls back to.
 """
 
 from __future__ import annotations
@@ -15,22 +16,10 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from ..quiet import quiet
-from ..utils import utc_now_iso
 from .common import (
     MAX_INDEX_TEXT_CHARS,
-    MODALITY_IMAGE,
     MODALITY_VIDEO,
     SUBTITLE_EXTENSIONS,
-    SUMMARY_CHARS,
-    _sha256_file,
-    _sha256_text,
-    _split_index_text,
-)
-from .images import (
-    _attach_concepts,
-    _attach_source,
-    extract_image_facts,
-    write_image_memory,
 )
 from .ports import DEFAULT_KEYFRAMES, MultimodalPorts, extract_keyframes
 
@@ -180,231 +169,3 @@ def video_quality_score(facts: VideoFacts) -> Dict[str, Any]:
     return {"score": round(max(0.0, min(1.0, score)), 4), "reasons": reasons}
 
 
-def video_node_id(content_hash: str, workspace_id: Optional[str] = None) -> str:
-    """Workspace-scoped, content-addressed id — re-ingesting is idempotent."""
-    scoped = f"{workspace_id or 'legacy-global'}|{content_hash}"
-    return f"video:{_sha256_text(scoped)[:24]}"
-
-
-def video_frame_dir(blob_dir: Any, content_hash: str) -> Path:
-    """Where this video's stills live: content-addressed, stable across runs.
-
-    Deliberately under the Brain's own blob directory rather than a temp dir.
-    A frame referenced by an ``Image`` node has to still be there the next time
-    someone opens that memory, and a backup that copies the blobs copies these.
-    """
-    return Path(str(blob_dir)) / "video_frames" / str(content_hash)[:32]
-
-
-def write_video_memory(
-    store: Any,
-    *,
-    path: Path,
-    facts: VideoFacts,
-    title: str,
-    source_type: str = MODALITY_VIDEO,
-    source_uri: Optional[str] = None,
-    owner: Optional[str] = None,
-    workspace_id: Optional[str] = None,
-    conversation_id: Optional[str] = None,
-    captured_at: Optional[str] = None,
-    modified_at: Optional[str] = None,
-    permissions: Optional[Dict[str, Any]] = None,
-    extra_metadata: Optional[Dict[str, Any]] = None,
-    ports: Optional[MultimodalPorts] = None,
-) -> Dict[str, Any]:
-    """Write one ``Video`` node, its keyframes, and its subtitles.
-
-    Each keyframe goes through the **existing image path** — the same
-    :func:`extract_image_facts` and :func:`write_image_memory` a photograph
-    uses — so a still from a video is OCR'd, captioned, vectorized and made
-    searchable by exactly the machinery that already does that, and joined to
-    its video by ``CONTAINS_IMAGE``. Subtitles ride the ordinary text index as
-    chunks. Nothing about video gets its own retrieval path.
-
-    The frames are written before the video node so their (short-lived) write
-    transactions never nest inside the video's.
-    """
-    ports = ports or MultimodalPorts()
-    captured_at = captured_at or utc_now_iso()
-    content_hash = _sha256_file(path)
-    node_id = video_node_id(content_hash, workspace_id)
-    frames = _write_keyframes(
-        store,
-        facts=facts,
-        title=title,
-        owner=owner,
-        workspace_id=workspace_id,
-        conversation_id=conversation_id,
-        captured_at=captured_at,
-        permissions=permissions,
-        ports=ports,
-    )
-    body = facts.subtitle_text or (
-        f"[{MODALITY_VIDEO}] {title}\n"
-        "이 영상에는 자막이 없어 말의 내용은 검색되지 않습니다 — "
-        "대신 대표 장면 이미지로 찾을 수 있습니다."
-    )
-    metadata: Dict[str, Any] = {
-        "filename": path.name,
-        "file_path": str(path),
-        "ext": path.suffix.lower(),
-        "bytes": path.stat().st_size,
-        "sha256": content_hash,
-        "content_hash": content_hash,
-        "source_type": source_type,
-        "source_uri": source_uri or str(path),
-        "captured_at": captured_at,
-        "modified_at": modified_at,
-        "owner": owner,
-        "workspace_id": workspace_id,
-        "permissions": permissions or {},
-        "conversation_id": conversation_id,
-        "keyframe_nodes": [frame["node_id"] for frame in frames],
-        **facts.as_metadata(),
-        **(extra_metadata or {}),
-    }
-    # Honest card: a video nobody captioned says so, rather than rendering as a
-    # blank summary that looks like a failed read.
-    summary = body[:SUMMARY_CHARS]
-    chunk_ids: List[str] = []
-    with store._connect() as conn:
-        duplicate = (
-            conn.execute("SELECT 1 FROM nodes WHERE id=? LIMIT 1", (node_id,)).fetchone()
-            is not None
-        )
-        store._upsert_node(
-            conn,
-            node_id,
-            VIDEO_NODE_TYPE,
-            title or path.name,
-            summary=summary,
-            metadata=metadata,
-            raw=metadata,
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-        for frame in frames:
-            store._upsert_edge(
-                conn,
-                node_id,
-                frame["node_id"],
-                VIDEO_FRAME_RELATION,
-                weight=0.8,
-                metadata={
-                    "source": VIDEO_FRAME_SOURCE_TYPE,
-                    "index": frame["index"],
-                    "workspace_id": workspace_id,
-                },
-            )
-        for index, piece in enumerate(_split_index_text(facts.subtitle_text)):
-            chunk_id = f"chunk:{_sha256_text(f'{node_id}:{index}:{piece}')[:24]}"
-            chunk_ids.append(chunk_id)
-            chunk_meta = {
-                "index": index,
-                "source_node": node_id,
-                "workspace_id": workspace_id,
-                "modality": MODALITY_VIDEO,
-            }
-            store._upsert_node(
-                conn,
-                chunk_id,
-                "Chunk",
-                f"{path.name} chunk {index + 1}",
-                summary=piece[:SUMMARY_CHARS],
-                metadata=chunk_meta,
-                owner=owner,
-                workspace_id=workspace_id,
-            )
-            store._upsert_chunk(
-                conn,
-                chunk_id=chunk_id,
-                source_node=node_id,
-                text=piece,
-                metadata=chunk_meta,
-            )
-            store._upsert_edge(conn, node_id, chunk_id, "포함함")
-        concept_ids = _attach_concepts(
-            store,
-            conn,
-            node_id=node_id,
-            text=facts.subtitle_text,
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-        source_node_id = _attach_source(
-            store,
-            conn,
-            node_id=node_id,
-            source_type=source_type,
-            source_uri=source_uri or str(path),
-            title=title or path.name,
-            content_hash=content_hash,
-            captured_at=captured_at,
-            owner=owner,
-            workspace_id=workspace_id,
-        )
-    metadata["concepts"] = concept_ids
-    return {
-        "node_id": node_id,
-        "type": VIDEO_NODE_TYPE,
-        "title": title or path.name,
-        "sha256": content_hash,
-        "content_hash": content_hash,
-        "source_node_id": source_node_id,
-        "chunk_ids": chunk_ids,
-        "chunk_count": len(chunk_ids),
-        "duplicate": duplicate,
-        "captured_at": captured_at,
-        "keyframes": frames,
-        "metadata": metadata,
-    }
-
-
-def _write_keyframes(
-    store: Any,
-    *,
-    facts: VideoFacts,
-    title: str,
-    owner: Optional[str],
-    workspace_id: Optional[str],
-    conversation_id: Optional[str],
-    captured_at: str,
-    permissions: Optional[Dict[str, Any]],
-    ports: MultimodalPorts,
-) -> List[Dict[str, Any]]:
-    """Every extracted still, through the ordinary image door."""
-    written: List[Dict[str, Any]] = []
-    for index, frame_path in enumerate(facts.keyframes):
-        frame = Path(frame_path)
-        image_facts = extract_image_facts(str(frame), ports=ports)
-        if not image_facts.readable:
-            # A frame ffmpeg wrote that Pillow cannot open is a state worth
-            # skipping, not worth failing the whole video over.
-            continue
-        result = write_image_memory(
-            store,
-            path=frame,
-            facts=image_facts,
-            title=f"{title} · 장면 {index + 1}",
-            source_type=VIDEO_FRAME_SOURCE_TYPE,
-            source_uri=str(frame),
-            owner=owner,
-            workspace_id=workspace_id,
-            conversation_id=conversation_id,
-            captured_at=captured_at,
-            permissions=permissions,
-            extra_metadata={
-                "modality": MODALITY_IMAGE,
-                "video_path": facts.path,
-                "keyframe_index": index,
-            },
-        )
-        written.append({
-            "node_id": result["node_id"],
-            "index": index,
-            "path": str(frame),
-            "ocr_status": image_facts.ocr_status,
-            "vision_embedding": image_facts.embedding_status,
-        })
-    return written

package/lattice_brain/runtime/__init__.py

@@ -1,90 +1,19 @@
-"""Agent and hook runtime subsystem of the Brain Core.
+"""The tool dispatch lifecycle.
 
-Physically hosts the hooks registry/dispatch lifecycle, the multi-agent
-orchestrator, and the agent runtime service. Lazy-loaded so importing
-``lattice_brain.runtime`` stays cheap.
-
-=== lattice_brain/runtime 책임 + 의존성 그래프 (A방향 + Act/automation 기준) ===
-- multi_agent.py (핵심 실행체)
-  책임: OrchestrationContext, AgentContextPacket, AgentHandoff, AgentRunResult,
-        MultiAgentOrchestrator, default_role_runner, llm_role_runner,
-        CORE_PIPELINE/AGENT_ROLES, handoff/review/retry 타임라인 생성.
-  의존: 없음 (순수, deterministic/LLM runner 주입).
-  진입: orchestrator_factory 로 AgentRuntime에 주입됨.
-
-- hooks.py (라이프사이클 확장)
-  책임: HookContext/HookResult, HooksRegistry (builtin+user, order/enabled persist),
-        dispatch_tool (pre_tool/post_tool 통합), fire_hook/run_hooks,
-        BUILTIN_HOOKS (redact, memory-snapshot, tool-permission-gate 등).
-  의존: subprocess (user command hooks).
-  진입: AgentRuntime, tool_dispatch, api/tools, core/agent 등에 주입/등록.
-
-- agent_runtime.py (공개 퍼사드 / 바운더리)
-  책임: AgentRuntime (store+orchestrator_factory+workspace_graph+audit+hooks 주입),
-        start/reserve_run/complete_reserved_run, stop, status/health/config,
-        list_runs/get_run/events/replay, _fire_pre_run / _post_run_hooks.
-  의존: .multi_agent, .hooks (간접), store (WORKSPACE_OS).
-  진입점: **여기가 제품 경계**. app_factory에서 AGENT_RUNTIME으로 생성,
-         api/agents.py (런타임 라우터), RunExecutor (async agent/workflow),
-         workflow_designer에 주입. frontend BrainAutomationPanel / Act 가
-         /agents/* 를 통해 이 바운더리만 의존.
-
-- __init__.py : lazy re-export (import 비용 최소화).
-
-실제 진입점 매핑 (app_factory + 호출 스택):
-  app_factory.py:1508
-    AGENT_RUNTIME = AgentRuntime(store=WORKSPACE_OS, orchestrator_factory=PLATFORM.build_orchestrator, hooks=HOOKS_REGISTRY, ...)
-    RUN_EXECUTOR = RunExecutor(..., agent_runtime=AGENT_RUNTIME)
-    AGENT_RUNTIME.attach_executor(RUN_EXECUTOR)
-    create_agents_router(..., agent_runtime=AGENT_RUNTIME)
-    create_workflow_designer_router(..., run_executor=RUN_EXECUTOR, trigger_service=TRIGGER_SERVICE)
-  api/agents.py:49
-    from lattice_brain.runtime.agent_runtime import AgentRuntime
-    runtime = agent_runtime or AgentRuntime(...)  # fallback
-    /agents/api/runtime/* , POST /agents (start via runtime.start or executor)
-  api/chat.py
-    from latticeai.services.tool_dispatch import build_agent_runtime
-    -> latticeai/core/agent/:SingleAgentRuntime (별도 state/plan/transcript 머신, single-agent /agent 경로. dispatch_tool 만 공유)
-  latticeai/services/tool_dispatch.py:14
-    from latticeai.core.agent import SingleAgentRuntime
-    (tool governance + core single-agent용)
-  latticeai/services/platform_runtime.py
-    from lattice_brain.runtime.{hooks, multi_agent}
-  tests: test_hooks_dispatch.py, test_t7_triggers.py 등에서 직접 import lattice_brain.runtime.* 
-
-core/tool_registry.py (신규) + services/tool_dispatch.py 가 tool build 주도.
-lattice_brain/runtime 는 multi-agent + hooks + facade 에 집중. core/agent 는 chat/agent 단일 루프.
-기존 latticeai.core.agent.AgentRuntime import 는 SingleAgentRuntime 호환 alias 로 유지.
-
-이 매핑으로 중복 제거 및 wiring 명확화 완료 (feat(Act, automation) 방향).
+This subsystem held the multi-agent orchestrator, the agent runtime facade and
+the persisted hooks registry. Orchestration is ``lattice-agent``'s and the hooks
+platform is ``lattice-platform``'s since v11.6.0; what remains is
+:func:`~lattice_brain.runtime.hooks.dispatch_tool` and the two context objects a
+bound hook runner is handed.
 """
 
 from __future__ import annotations
 
-__all__ = [
-    "AgentRuntime",
-    "AgentRuntimeUnavailable",
-    "MultiAgentOrchestrator",
-    "RuntimeBoundaryProtocol",
-    "HooksRegistry",
-    "dispatch_tool",
-]
+__all__ = ["HookContext", "HookResult", "dispatch_tool"]
 
 
 def __getattr__(name: str):
-    if name in {"AgentRuntime", "AgentRuntimeUnavailable"}:
-        from . import agent_runtime
-
-        return getattr(agent_runtime, name)
-    if name == "MultiAgentOrchestrator":
-        from .multi_agent import MultiAgentOrchestrator
-
-        return MultiAgentOrchestrator
-    if name == "RuntimeBoundaryProtocol":
-        from .contracts import RuntimeBoundaryProtocol
-
-        return RuntimeBoundaryProtocol
-    if name in {"HooksRegistry", "dispatch_tool"}:
+    if name in set(__all__):
         from . import hooks
 
         return getattr(hooks, name)