ai-parrot-semantic 1.3.2__tar.gz

ai_parrot_semantic-1.3.2/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: ai-parrot-semantic
+Version: 1.3.2
+Summary: Governed semantic metric queries for AI-Parrot
+License-Expression: MIT
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: ai-parrot
+Requires-Dist: sqlglot<31,>=30.1
+Requires-Dist: jsonschema>=4.20
+Requires-Dist: pyyaml>=6
+Provides-Extra: duckdb
+Requires-Dist: duckdb>=1.0; extra == "duckdb"
+Provides-Extra: bigquery
+Requires-Dist: google-cloud-bigquery>=3.30; extra == "bigquery"
+
+# ai-parrot-semantic
+
+MIT satellite: native sqlglot compilation and ai-parrot governance.
+Install: `uv pip install 'ai-parrot-semantic[duckdb]'`.
+
+## Layering
+
+Generic semantic queries and the future accounting extension share this namespace.
+The accounting extension must remain independently importable.
+
+## Governance
+
+Models are governed by default and require a trusted `PermissionContext` plus an
+available PBAC evaluator; a policy may explicitly set `governed: false` for an
+ungoverned model. Hosts provide the PBAC factory and may opt in to a guarded,
+subject/session-scoped dataset sink. A plain dataset manager is not a valid
+sink.
+
+The current native compiler supports declared metrics, dimensions, time grains,
+declared one-to-many joins with fan-out rejection, filtered measures, and
+derived metrics. The `duckdb` extra provides the local execution backend; the
+`bigquery` extra provides BigQuery integration. See
+[`docs/tools/semantic-layer.md`](../../docs/tools/semantic-layer.md) for the
+user-facing semantic-layer documentation.

ai_parrot_semantic-1.3.2/README.md

@@ -0,0 +1,24 @@
+# ai-parrot-semantic
+
+MIT satellite: native sqlglot compilation and ai-parrot governance.
+Install: `uv pip install 'ai-parrot-semantic[duckdb]'`.
+
+## Layering
+
+Generic semantic queries and the future accounting extension share this namespace.
+The accounting extension must remain independently importable.
+
+## Governance
+
+Models are governed by default and require a trusted `PermissionContext` plus an
+available PBAC evaluator; a policy may explicitly set `governed: false` for an
+ungoverned model. Hosts provide the PBAC factory and may opt in to a guarded,
+subject/session-scoped dataset sink. A plain dataset manager is not a valid
+sink.
+
+The current native compiler supports declared metrics, dimensions, time grains,
+declared one-to-many joins with fan-out rejection, filtered measures, and
+derived metrics. The `duckdb` extra provides the local execution backend; the
+`bigquery` extra provides BigQuery integration. See
+[`docs/tools/semantic-layer.md`](../../docs/tools/semantic-layer.md) for the
+user-facing semantic-layer documentation.

ai_parrot_semantic-1.3.2/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=77.0.0", "wheel>=0.44.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ai-parrot-semantic"
+dynamic = ["version"]
+description = "Governed semantic metric queries for AI-Parrot"
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+license = "MIT"
+dependencies = ["ai-parrot", "sqlglot>=30.1,<31", "jsonschema>=4.20", "pyyaml>=6"]
+
+[project.optional-dependencies]
+duckdb = ["duckdb>=1.0"]
+bigquery = ["google-cloud-bigquery>=3.30"]
+
+[tool.setuptools.dynamic]
+version = {attr = "parrot.semantic.version.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["parrot*"]
+namespaces = true
+
+[tool.setuptools.package-data]
+"parrot.semantic" = ["schemas/*.json", "sql/*.sql"]
+
+[tool.uv.sources]
+ai-parrot = {workspace = true}

ai_parrot_semantic-1.3.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ai_parrot_semantic-1.3.2/src/ai_parrot_semantic.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: ai-parrot-semantic
+Version: 1.3.2
+Summary: Governed semantic metric queries for AI-Parrot
+License-Expression: MIT
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: ai-parrot
+Requires-Dist: sqlglot<31,>=30.1
+Requires-Dist: jsonschema>=4.20
+Requires-Dist: pyyaml>=6
+Provides-Extra: duckdb
+Requires-Dist: duckdb>=1.0; extra == "duckdb"
+Provides-Extra: bigquery
+Requires-Dist: google-cloud-bigquery>=3.30; extra == "bigquery"
+
+# ai-parrot-semantic
+
+MIT satellite: native sqlglot compilation and ai-parrot governance.
+Install: `uv pip install 'ai-parrot-semantic[duckdb]'`.
+
+## Layering
+
+Generic semantic queries and the future accounting extension share this namespace.
+The accounting extension must remain independently importable.
+
+## Governance
+
+Models are governed by default and require a trusted `PermissionContext` plus an
+available PBAC evaluator; a policy may explicitly set `governed: false` for an
+ungoverned model. Hosts provide the PBAC factory and may opt in to a guarded,
+subject/session-scoped dataset sink. A plain dataset manager is not a valid
+sink.
+
+The current native compiler supports declared metrics, dimensions, time grains,
+declared one-to-many joins with fan-out rejection, filtered measures, and
+derived metrics. The `duckdb` extra provides the local execution backend; the
+`bigquery` extra provides BigQuery integration. See
+[`docs/tools/semantic-layer.md`](../../docs/tools/semantic-layer.md) for the
+user-facing semantic-layer documentation.

ai_parrot_semantic-1.3.2/src/ai_parrot_semantic.egg-info/SOURCES.txt

@@ -0,0 +1,63 @@
+README.md
+pyproject.toml
+src/ai_parrot_semantic.egg-info/PKG-INFO
+src/ai_parrot_semantic.egg-info/SOURCES.txt
+src/ai_parrot_semantic.egg-info/dependency_links.txt
+src/ai_parrot_semantic.egg-info/requires.txt
+src/ai_parrot_semantic.egg-info/top_level.txt
+src/parrot/semantic/__init__.py
+src/parrot/semantic/audit.py
+src/parrot/semantic/bootstrap.py
+src/parrot/semantic/cache.py
+src/parrot/semantic/catalog.py
+src/parrot/semantic/context.py
+src/parrot/semantic/errors.py
+src/parrot/semantic/execution.py
+src/parrot/semantic/handoff.py
+src/parrot/semantic/loader.py
+src/parrot/semantic/model.py
+src/parrot/semantic/models.py
+src/parrot/semantic/ossie.py
+src/parrot/semantic/policy.py
+src/parrot/semantic/results.py
+src/parrot/semantic/toolkit.py
+src/parrot/semantic/version.py
+src/parrot/semantic/engines/__init__.py
+src/parrot/semantic/engines/native.py
+src/parrot/semantic/governance/__init__.py
+src/parrot/semantic/governance/guard.py
+src/parrot/semantic/governance/lineage.py
+src/parrot/semantic/governance/masking.py
+src/parrot/semantic/governance/pbac.py
+src/parrot/semantic/governance/pipeline.py
+src/parrot/semantic/governance/rls.py
+src/parrot/semantic/schemas/ossie-0.1.1.schema.json
+src/parrot/semantic/sql/semantic_audit_events.sql
+tests/test_audit.py
+tests/test_bootstrap.py
+tests/test_cache.py
+tests/test_catalog.py
+tests/test_context.py
+tests/test_e2e_governed.py
+tests/test_e2e_handoff.py
+tests/test_example_agent.py
+tests/test_execution.py
+tests/test_handoff_contract.py
+tests/test_lineage.py
+tests/test_loader.py
+tests/test_masking.py
+tests/test_mcp_local.py
+tests/test_model_graph.py
+tests/test_models.py
+tests/test_native_compiler.py
+tests/test_native_extensions.py
+tests/test_ossie.py
+tests/test_packaging.py
+tests/test_pbac.py
+tests/test_pipeline.py
+tests/test_policy.py
+tests/test_positive_guard.py
+tests/test_results.py
+tests/test_rls_ownership.py
+tests/test_rls_pushdown.py
+tests/test_toolkit.py

ai_parrot_semantic-1.3.2/src/ai_parrot_semantic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ai_parrot_semantic-1.3.2/src/ai_parrot_semantic.egg-info/requires.txt

@@ -0,0 +1,10 @@
+ai-parrot
+sqlglot<31,>=30.1
+jsonschema>=4.20
+pyyaml>=6
+
+[bigquery]
+google-cloud-bigquery>=3.30
+
+[duckdb]
+duckdb>=1.0

ai_parrot_semantic-1.3.2/src/ai_parrot_semantic.egg-info/top_level.txt

@@ -0,0 +1 @@
+parrot

ai_parrot_semantic-1.3.2/src/parrot/semantic/__init__.py

@@ -0,0 +1,7 @@
+"""Governed semantic queries using the native sqlglot compiler."""
+
+from .version import __version__
+from .models import SemanticQuery, SemanticQueryResult
+from .toolkit import SemanticLayerToolkit
+
+__all__ = ["__version__", "SemanticQuery", "SemanticQueryResult", "SemanticLayerToolkit"]

ai_parrot_semantic-1.3.2/src/parrot/semantic/audit.py

@@ -0,0 +1,206 @@
+"""Signed semantic audit ledger (spec §3 Module 8, §8 Q3/Q5)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from collections import deque
+from datetime import datetime
+from typing import Any, Awaitable, Callable, Literal
+
+from pydantic import BaseModel
+
+from parrot.security import AbstractKMSSigner, LocalHMACSigner
+
+from .errors import SemanticExecutionError
+
+logger = logging.getLogger(__name__)
+
+_IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,62}$")
+
+
+class SemanticAuditEntry(BaseModel):
+    """One signed audit record for a semantic tool call.
+
+    ``engine`` is provenance only and is always ``"native"``. SQL text lives here,
+    never in exception messages.
+    """
+
+    schema_version: int = 1
+    entry_id: str
+    created_at: datetime
+    user_id: str
+    tenant_id: str
+    channel: str
+    agent_id: str | None
+    subject_digest: str
+    roles: list[str]
+    static_subject: bool
+    model: str
+    model_digest: str
+    policy_digest: str
+    engine: Literal["native"] = "native"
+    tool: str
+    structured_query: dict | None
+    raw_sql: bool
+    compiled_sql: str | None
+    governed_sql: str | None
+    dialect: str
+    driver: str
+    rls_applied: list[str]
+    masked_columns: list[str]
+    pbac: Literal["allow", "deny", "unavailable", "not_governed"]
+    outcome: Literal["ok", "denied", "validation_error", "execution_error"]
+    error_code: str | None
+    row_count: int | None
+    duration_ms: int | None
+    signature: str = ""
+
+    def canonical_bytes(self) -> bytes:
+        """Return sorted-key compact JSON of the entry, excluding ``signature``.
+
+        Returns:
+            Canonical UTF-8 bytes used for signing and verification.
+        """
+        data = self.model_dump(mode="json", exclude={"signature"})
+        return json.dumps(data, sort_keys=True, separators=(",", ":")).encode()
+
+
+class SemanticAuditLedger:
+    """Bounded in-memory signed ledger with an optional async durable sink.
+
+    Args:
+        signer: Async KMS signer; defaults to a process-local HMAC signer.
+        storage: Async callable receiving the entry JSON; makes the ledger durable.
+        max_entries: Maximum number of entries kept in memory.
+    """
+
+    def __init__(
+        self,
+        signer: AbstractKMSSigner | None = None,
+        storage: Callable[[str], Awaitable[None]] | None = None,
+        max_entries: int = 10_000,
+    ) -> None:
+        self.signer: AbstractKMSSigner = signer or LocalHMACSigner()
+        self.storage = storage
+        self.entries: deque[SemanticAuditEntry] = deque(maxlen=max_entries)
+        self.logger = logger
+
+    @property
+    def durable(self) -> bool:
+        """True when a storage callable is configured (drives audit_required=None, §8 Q5)."""
+        return self.storage is not None
+
+    async def append(self, entry: SemanticAuditEntry, *, required: bool = False) -> SemanticAuditEntry:
+        """Sign the entry, keep it in memory and forward it to storage.
+
+        Args:
+            entry: The audit entry to record.
+            required: When True, a missing or failing sink raises instead of logging.
+
+        Returns:
+            The signed entry.
+
+        Raises:
+            SemanticExecutionError: ``audit_unavailable`` when required and the sink fails.
+        """
+        entry.signature = await self.signer.sign(entry.canonical_bytes())
+        self.entries.append(entry)
+        if self.storage is None:
+            if required:
+                raise SemanticExecutionError(
+                    "audit_unavailable", "Audit storage is not configured", details={"audit_id": entry.entry_id}
+                )
+            return entry
+        try:
+            await self.storage(entry.model_dump_json())
+        except Exception as exc:  # noqa: BLE001 - sink failures are policy-handled
+            self.logger.error("Semantic audit sink failed for %s: %s", entry.entry_id, type(exc).__name__)
+            if required:
+                raise SemanticExecutionError(
+                    "audit_unavailable", "Audit storage failed", details={"audit_id": entry.entry_id}
+                ) from exc
+        return entry
+
+    async def verify(self, entry: SemanticAuditEntry) -> bool:
+        """Verify the entry's signature with the configured async signer.
+
+        Args:
+            entry: Entry to verify.
+
+        Returns:
+            True when the signature matches the canonical content.
+        """
+        if not entry.signature:
+            return False
+        return await self.signer.verify(entry.canonical_bytes(), entry.signature)
+
+
+def _quote_table(table: str) -> str:
+    """Validate a bare or schema-qualified identifier and return it double-quoted.
+
+    Args:
+        table: ``name`` or ``schema.name``.
+
+    Returns:
+        The quoted identifier.
+
+    Raises:
+        ValueError: If any part is not a plain identifier.
+    """
+    parts = table.split(".")
+    if not 1 <= len(parts) <= 2 or not all(_IDENTIFIER.match(p) for p in parts):
+        raise ValueError("Invalid audit table identifier")
+    return ".".join(f'"{p}"' for p in parts)
+
+
+def postgres_audit_storage(
+    dsn_or_pool: str | Any, *, table: str = "semantic_audit_events"
+) -> Callable[[str], Awaitable[None]]:
+    """Build an async storage callable that INSERTs entries into Postgres.
+
+    An injected pool (anything with ``acquire()``) is never closed. A DSN string
+    opens an owned asyncpg connection per write, always closed afterwards.
+
+    Args:
+        dsn_or_pool: asyncpg DSN or an existing pool.
+        table: Target table (DDL: ``parrot/semantic/sql/semantic_audit_events.sql``).
+
+    Returns:
+        ``async storage(json_str)``.
+    """
+    quoted = _quote_table(table)
+    sql = (
+        f"INSERT INTO {quoted} (entry_id, created_at, user_id, tenant_id, model, outcome, payload, signature) "
+        "VALUES ($1::uuid, $2, $3, $4, $5, $6, $7::jsonb, $8)"
+    )
+
+    def _params(payload: str) -> tuple[Any, ...]:
+        data = json.loads(payload)
+        return (
+            data["entry_id"],
+            datetime.fromisoformat(data["created_at"]),
+            data["user_id"],
+            data["tenant_id"],
+            data["model"],
+            data["outcome"],
+            payload,
+            data.get("signature", ""),
+        )
+
+    async def storage(payload: str) -> None:
+        params = _params(payload)
+        if isinstance(dsn_or_pool, str):
+            import asyncpg  # lazy: optional dependency
+
+            conn = await asyncpg.connect(dsn_or_pool)
+            try:
+                await conn.execute(sql, *params)
+            finally:
+                await conn.close()
+            return
+        async with dsn_or_pool.acquire() as conn:
+            await conn.execute(sql, *params)
+
+    return storage

ai_parrot_semantic-1.3.2/src/parrot/semantic/bootstrap.py

@@ -0,0 +1,191 @@
+"""Trusted stdio-only semantic toolkit bootstrap; never an HTTP identity fallback."""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+from uuid import uuid4
+
+from parrot.auth import DataPlanePolicyGuard, PermissionContext, RlsRegistry, UserSession
+from parrot.tools.toolkit import ToolkitTool
+from pydantic import BaseModel, Field
+
+from .context import SemanticRequestIdentity, bind_semantic_context, current_identity, current_pctx
+from .errors import SemanticAccessError, SemanticPolicyError
+from .toolkit import SemanticLayerToolkit
+
+_EVALUATOR_MODULES = (
+    "navigator_auth.abac.policies.environment",
+    "navigator_auth.abac.policies.evaluator",
+)
+
+
+class StaticSubject(BaseModel):
+    """Trusted local operator identity, never accepted as a tool argument."""
+
+    user_id: str = Field(min_length=1)
+    tenant_id: str = Field(min_length=1)
+    roles: list[str]
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class LocalSemanticToolkitTool(ToolkitTool):
+    """Bind the immutable local operator identity around one tool call."""
+
+    def __init__(self, *args: Any, local_toolkit: "LocalSemanticLayerToolkit", **kwargs: Any) -> None:
+        """Initialize the generated tool with its local-only toolkit owner."""
+        self._local_toolkit = local_toolkit
+        super().__init__(*args, **kwargs)
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute with the configured identity regardless of caller arguments."""
+        previous_context = getattr(self, "_current_pctx", None)
+        self._current_pctx = self._local_toolkit._static_permission_context
+        self._local_toolkit.logger.info(
+            "semantic static subject call tool=%s user=%s agent=%s",
+            self.name,
+            self._local_toolkit._static_permission_context.user_id,
+            self._local_toolkit._static_identity.agent_id,
+        )
+        try:
+            async with bind_semantic_context(
+                self._local_toolkit._static_permission_context,
+                identity=self._local_toolkit._static_identity,
+            ):
+                return await super()._execute(**kwargs)
+        finally:
+            self._current_pctx = previous_context
+
+
+class LocalSemanticLayerToolkit(SemanticLayerToolkit):
+    """Stdio-local subclass that builds its configured PBAC guard at startup."""
+
+    local_only = True
+
+    def __init__(
+        self,
+        *,
+        static_subject: StaticSubject | dict[str, Any],
+        agent_id: str,
+        guard_factory: str,
+        guard_factory_kwargs: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Resolve trusted factory, validate evaluator, create local process session.
+
+        Args:
+            static_subject: Trusted host configuration for the sole local operator.
+            agent_id: Host-configured semantic agent identifier.
+            guard_factory: Dotted host factory that creates a PBAC guard.
+            guard_factory_kwargs: Non-secret host configuration for the factory.
+            **kwargs: Ordinary :class:`SemanticLayerToolkit` constructor settings.
+
+        Raises:
+            SemanticPolicyError: If local identity or PBAC setup is invalid.
+        """
+        try:
+            subject = StaticSubject.model_validate(static_subject)
+        except Exception as exc:  # noqa: BLE001 - Pydantic reports malformed host configuration
+            raise SemanticPolicyError("invalid_static_subject", "Invalid local static subject") from exc
+        if not agent_id.strip():
+            raise SemanticPolicyError("invalid_agent_id", "A non-empty local agent_id is required")
+        if not isinstance(guard_factory, str) or not guard_factory.strip():
+            raise SemanticPolicyError("guard_factory_required", "A configured guard_factory is required")
+        if guard_factory_kwargs is not None and not isinstance(guard_factory_kwargs, dict):
+            raise SemanticPolicyError("invalid_guard_factory_kwargs", "guard_factory_kwargs must be a mapping")
+
+        self._require_evaluator_modules()
+        rls_registry = RlsRegistry()
+        guard = self._build_guard(guard_factory, rls_registry, guard_factory_kwargs or {})
+        self._static_permission_context = PermissionContext(
+            session=UserSession(
+                user_id=subject.user_id,
+                tenant_id=subject.tenant_id,
+                roles=frozenset(subject.roles),
+                metadata=dict(subject.metadata),
+            ),
+            channel="mcp-local",
+        )
+        self._static_identity = SemanticRequestIdentity(
+            ctx=self._static_permission_context,
+            channel="mcp-local",
+            agent_id=agent_id,
+            session_id=str(uuid4()),
+        )
+        super().__init__(dataplane_guard=guard, rls_registry=rls_registry, **kwargs)
+
+    @staticmethod
+    def _require_evaluator_modules() -> None:
+        """Require the exact navigator-auth modules used by the PBAC gate."""
+        try:
+            evaluator_module, environment_module = (
+                importlib.import_module(module) for module in reversed(_EVALUATOR_MODULES)
+            )
+            if not (hasattr(evaluator_module, "PolicyEvaluator") and hasattr(environment_module, "Environment")):
+                raise AttributeError("PolicyEvaluator or Environment is missing")
+        except (AttributeError, ImportError, ModuleNotFoundError) as exc:
+            raise SemanticPolicyError("pbac_unavailable", "Required PBAC evaluator modules are unavailable") from exc
+
+    @staticmethod
+    def _build_guard(
+        factory_path: str, rls_registry: RlsRegistry, factory_kwargs: dict[str, Any]
+    ) -> DataPlanePolicyGuard:
+        """Load and invoke a trusted host PBAC guard factory.
+
+        Args:
+            factory_path: Dotted callable path from host configuration.
+            rls_registry: Registry shared with the semantic toolkit.
+            factory_kwargs: Non-secret factory configuration.
+
+        Returns:
+            Configured data-plane guard.
+
+        Raises:
+            SemanticPolicyError: If the configured factory cannot provide a valid guard.
+        """
+        try:
+            module_path, attribute = factory_path.rsplit(".", 1)
+            factory = getattr(importlib.import_module(module_path), attribute)
+        except (AttributeError, ImportError, ModuleNotFoundError, ValueError) as exc:
+            raise SemanticPolicyError("invalid_guard_factory", "Configured guard_factory cannot be loaded") from exc
+        if not callable(factory):
+            raise SemanticPolicyError("invalid_guard_factory", "Configured guard_factory must be callable")
+        try:
+            guard = factory(rls_registry=rls_registry, **factory_kwargs)
+        except Exception as exc:  # noqa: BLE001 - policy construction must fail startup
+            raise SemanticPolicyError("guard_factory_failed", "Configured PBAC policy could not be loaded") from exc
+        if not isinstance(guard, DataPlanePolicyGuard) or getattr(guard, "_evaluator", None) is None:
+            raise SemanticPolicyError(
+                "invalid_policy_guard", "guard_factory must return a configured DataPlanePolicyGuard"
+            )
+        return guard
+
+    def _create_tool_from_method(self, name: str, bound_method: callable) -> ToolkitTool:
+        """Create tools that always bind this toolkit's configured local identity."""
+        base_tool = super()._create_tool_from_method(name, bound_method)
+        local_tool = LocalSemanticToolkitTool(
+            name=base_tool.name,
+            bound_method=bound_method,
+            description=base_tool.description,
+            args_schema=base_tool.args_schema,
+            return_direct=base_tool.return_direct,
+            executor=base_tool.executor,
+            webhook_callback_url=base_tool.webhook_callback_url,
+            remote_timeout_seconds=base_tool.remote_timeout_seconds,
+            local_toolkit=self,
+        )
+        for attribute in ("_required_permissions", "credential_provider", "routing_meta"):
+            if hasattr(base_tool, attribute):
+                setattr(local_tool, attribute, getattr(base_tool, attribute))
+        return local_tool
+
+    def _audit_identity(self) -> tuple[Any, str, str | None, bool]:
+        """Return the immutable local identity for audit entries; refuse any other binding.
+
+        Raises:
+            SemanticAccessError: When the bound identity is not this toolkit's static identity.
+        """
+        context = current_pctx()
+        if context is None or current_identity() != self._static_identity:
+            raise SemanticAccessError("context_required", "A matching local semantic context is required")
+        return context, "mcp-local", self._static_identity.agent_id, True