Multi-Tenant Operations Guide¶

from pathlib import Path

# Imports from layered architecture
from cogniverse_foundation.config.unified_config import SystemConfig  # Foundation layer
from cogniverse_foundation.config.utils import create_default_config_manager  # Foundation layer
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader  # Core layer

# Initialize managers
config_manager = create_default_config_manager()
schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))

# Create new tenant
tenant_id = "acme_corp"

# 1. Ensure global system configuration is set (once for the whole deployment)
# SystemConfig is NOT per-tenant — it holds deployment-wide infrastructure settings.
system_config = SystemConfig(
    llm_model="openai/google/gemma-4-e4b-it",
    base_url="http://localhost:11434",
    backend_url="http://localhost",
    backend_port=8080,
    telemetry_url="http://localhost:6006",
)
config_manager.set_system_config(system_config)

# 2. Deploy schemas using script (from project root)
# JAX_PLATFORM_NAME=cpu uv run python scripts/deploy_json_schema.py configs/schemas/video_colpali_smol500_mv_frame_schema.json

# 3. Initialize tenant memory
from cogniverse_core.memory.manager import Mem0MemoryManager  # Core layer
from cogniverse_core.memory.schema import build_default_registry

memory_manager = Mem0MemoryManager(tenant_id=tenant_id)
memory_manager.initialize(
    backend_host="localhost",
    backend_port=8080,
    llm_model="openai/google/gemma-4-e4b-it",
    embedding_model="lightonai/DenseOn",
    llm_base_url="http://localhost:11434",
    embedder_base_url="http://localhost:8000",  # Required: DenseOn /v1 endpoint
    config_manager=config_manager,
    schema_loader=schema_loader,
    # Enables schema enforcement (provenance + trust + reconciliation)
    knowledge_registry=build_default_registry(),
)

print(f"✅ Tenant {tenant_id} created successfully")
print(f"   Config: Stored in config manager")
# TelemetryConfig.tenant_project_template is "cogniverse-{tenant_id}"
print(f"   Telemetry Project: cogniverse-{tenant_id}")
print(f"   Memory: Initialized with backend isolation")

from cogniverse_foundation.config.unified_config import RoutingConfigUnified  # Foundation layer

# Configure routing for tenant
routing_config = RoutingConfigUnified(
    tenant_id=tenant_id,
    # "tiered" is the only mode implemented end-to-end (fast + slow +
    # fallback path below). Other string values are accepted by the
    # dataclass for forward-compat but produce no behavior change at
    # dispatch time — do not rely on them.
    routing_mode="tiered",
    enable_fast_path=True,
    enable_slow_path=True,
    fast_path_confidence_threshold=0.7,
    slow_path_confidence_threshold=0.6,
    enable_auto_optimization=True,
    optimization_interval_seconds=3600
)

config_manager.set_routing_config(routing_config)

print(f"✅ Routing configured for {tenant_id}")

# Soft delete (preserves configuration history)
def soft_delete_tenant(tenant_id: str):
    """Soft delete - keeps configuration history"""
    from datetime import datetime

    # 1. Mark tenant as inactive via per-tenant routing config metadata
    from cogniverse_foundation.config.unified_config import RoutingConfigUnified
    routing_config = config_manager.get_routing_config(tenant_id=tenant_id)
    if routing_config is None:
        routing_config = RoutingConfigUnified(tenant_id=tenant_id)
    # Ensure metadata dict exists
    if not routing_config.metadata:
        routing_config.metadata = {}
    routing_config.metadata["status"] = "inactive"
    routing_config.metadata["deactivated_at"] = datetime.now().isoformat()
    config_manager.set_routing_config(routing_config, tenant_id=tenant_id)

    # 2. Stop accepting new requests
    # (handled by application layer checking metadata["status"])

    # 3. Preserve data for retention period
    print(f"✅ Tenant {tenant_id} marked inactive")
    print(f"   Data retention: 90 days")
    print(f"   Can be reactivated within retention period")

# Hard delete (permanent removal). Prefer
# `curl -X DELETE $RUNTIME_URL/admin/tenants/{tenant_id}` (see "0. Register
# Tenant" above) — it does steps 1+3 below in one call via the same
# `delete_tenant_internal` code path. The function here shows what that
# endpoint does under the hood for callers driving it directly.
def hard_delete_tenant(tenant_id: str):
    """Hard delete - permanent removal"""

    # 1. Delete backend schemas — redeploys the Vespa application package
    # with allow_schema_removal=True (validation override required for
    # content type removal), then tombstones the SchemaRegistry entries.
    # schema_manager here is a VespaSchemaManager, normally obtained via
    # backend.schema_manager rather than constructed directly (it needs
    # a wired SchemaRegistry) — this function shows what happens
    # server-side, use the DELETE endpoint above for real operations.
    schema_manager.delete_tenant_schemas(tenant_id)

    # 2. Delete telemetry project
    # (manual cleanup required via telemetry provider UI or API)

    # 3. Delete configurations (if delete method exists)
    # config_manager.delete_tenant_config(tenant_id)

    # 4. Clear memory (clear for all agents under this tenant)
    memory_manager = Mem0MemoryManager(tenant_id=tenant_id)
    # Note: clear_agent_memory requires agent_name parameter
    # For full tenant cleanup, iterate through all agents or use backend API

    print(f"✅ Tenant {tenant_id} permanently deleted")

# Usage
soft_delete_tenant("acme_corp")  # Default: soft delete
# hard_delete_tenant("acme_corp")  # Use with caution

# List all schemas via backend API
import requests

backend_url = "http://localhost:8080"

# Query backend for deployed schemas
response = requests.get(f"{backend_url}/ApplicationStatus")
if response.status_code == 200:
    # Parse schema names from response
    # (Implementation depends on backend API response format)
    print("Schemas deployed successfully")
else:
    print(f"Failed to query schemas: {response.status_code}")

# Note: Schema listing is best done via backend CLI or API
# Tenant-specific schemas follow pattern: {base_schema}_{tenant_id}

# schema_manager is a VespaSchemaManager (backend.schema_manager),
# normally reached through the runtime rather than constructed
# directly — shown here as the library call the Admin API wraps.

# Single-tenant delete — refuses (raises BackendDeploymentError) if an
# unrelated peer-tenant orphan would be left dangling by the redeploy.
schema_manager.delete_tenant_schemas("acme:prod")

# Multi-tenant atomic delete — refuses (does not absorb) an unconfirmable
# survivor outside the named tenants; drops only genuine orphans.
schema_manager.delete_tenant_schemas_bulk(["acme:prod", "globex:dev"])

from pathlib import Path

async def ingest_tenant_videos(tenant_id: str, video_dir: Path):
    """Ingest all videos for a tenant"""

    video_files = list(video_dir.glob("*.mp4"))
    print(f"Processing {len(video_files)} videos for {tenant_id}")

    # Use the ingestion script (recommended approach)
    import subprocess
    result = subprocess.run([
        "uv", "run", "python", "scripts/run_ingestion.py",
        "--video_dir", str(video_dir),
        "--backend", "vespa",
        "--profile", "video_colpali_smol500_mv_frame",
        "--tenant-id", tenant_id
    ], capture_output=True, text=True)

    if result.returncode == 0:
        print(f"✓ Ingestion completed for {tenant_id}")
    else:
        print(f"✗ Ingestion failed: {result.stderr}")

    return result.returncode == 0

# Usage (in async context)
import asyncio

asyncio.run(ingest_tenant_videos("acme_corp", Path("data/videos/acme_corp")))
asyncio.run(ingest_tenant_videos("globex_inc", Path("data/videos/globex_inc")))

from cogniverse_agents.search_agent import SearchAgent, SearchAgentDeps
from cogniverse_foundation.config.utils import create_default_config_manager
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader
from pathlib import Path

# Initialize once — ONE agent serves ALL tenants
config_manager = create_default_config_manager()
schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))

agent = SearchAgent(
    deps=SearchAgentDeps(profile="video_colpali_smol500_mv_frame"),
    config_manager=config_manager,
    schema_loader=schema_loader,
)

def search_tenant_videos(
    tenant_id: str,
    query: str,
    top_k: int = 10
):
    """Search videos within tenant isolation"""

    # tenant_id is a PER-REQUEST parameter on search_by_text()
    results = agent.search_by_text(
        query=query,
        tenant_id=tenant_id,
        top_k=top_k,
    )

    return results

# Search for acme_corp
acme_results = search_tenant_videos("acme_corp", "machine learning")

# Search for globex_inc (completely isolated)
globex_results = search_tenant_videos("globex_inc", "machine learning")

from cogniverse_foundation.telemetry.config import TelemetryConfig
from cogniverse_foundation.telemetry.manager import TelemetryManager

# Initialize telemetry (singleton)
telemetry = TelemetryManager(
    config=TelemetryConfig(
        enabled=True,
        otlp_endpoint="localhost:4317"
    )
)

# All spans require tenant_id for isolation
tenant_id = "acme_corp"
with telemetry.span("video_search", tenant_id=tenant_id) as span:
    span.set_attribute("query", query)
    # ... perform search

from cogniverse_telemetry_phoenix.evaluation.analytics import PhoenixAnalytics
from datetime import datetime

# Admin can view aggregated metrics across tenants. tenant_ids would
# typically come from GET /admin/organizations/{org}/tenants for every
# org (see "0. Register Tenant" above) rather than being hard-coded.
tenant_ids = ["acme:production", "globex:dev"]

analytics = PhoenixAnalytics(telemetry_url="http://localhost:6006")

start_time = datetime(2025, 1, 1)
end_time = datetime(2025, 1, 31)

tenant_stats = {}
for tenant_id in tenant_ids:
    traces = analytics.get_traces(
        start_time=start_time,
        end_time=end_time,
        limit=10000,
        project_name=f"cogniverse-{tenant_id}",
    )

    stats = {"total": 0, "success": 0, "latencies": []}
    for trace in traces:
        stats["total"] += 1
        if trace.status == "success":
            stats["success"] += 1
        stats["latencies"].append(trace.duration_ms)
    tenant_stats[tenant_id] = stats

# Display metrics
for tenant_id, stats in tenant_stats.items():
    avg_latency = sum(stats["latencies"]) / len(stats["latencies"]) if stats["latencies"] else 0
    success_rate = stats["success"] / stats["total"] if stats["total"] > 0 else 0

    print(f"\n{tenant_id}:")
    print(f"  Total Queries: {stats['total']}")
    print(f"  Avg Latency: {avg_latency:.1f}ms")
    print(f"  Success Rate: {success_rate:.1%}")

from pathlib import Path

from cogniverse_core.memory.manager import Mem0MemoryManager
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader
from cogniverse_foundation.config.utils import create_default_config_manager

config_manager = create_default_config_manager()
schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))

# Get tenant-specific memory managers (per-tenant singleton pattern)
memory_acme = Mem0MemoryManager(tenant_id="acme_corp")
memory_acme.initialize(
    backend_host="localhost",
    backend_port=8080,
    llm_model="openai/google/gemma-4-e4b-it",
    embedding_model="lightonai/DenseOn",
    llm_base_url="http://localhost:11434",
    embedder_base_url="http://localhost:8000",  # Required: DenseOn /v1 endpoint
    config_manager=config_manager,
    schema_loader=schema_loader,
)

memory_globex = Mem0MemoryManager(tenant_id="globex_inc")
memory_globex.initialize(
    backend_host="localhost",
    backend_port=8080,
    llm_model="openai/google/gemma-4-e4b-it",
    embedding_model="lightonai/DenseOn",
    llm_base_url="http://localhost:11434",
    embedder_base_url="http://localhost:8000",  # Required: DenseOn /v1 endpoint
    config_manager=config_manager,
    schema_loader=schema_loader,
)

# Add memory for acme_corp
memory_acme.add_memory(
    content="User prefers technical tutorials",
    tenant_id="acme_corp",
    agent_name="video_search_agent"
)

# Search memory (tenant-isolated)
memories = memory_acme.search_memory(
    query="What does the user prefer?",
    tenant_id="acme_corp",
    agent_name="video_search_agent",
    top_k=5
)

# Memories are completely isolated per tenant

from cogniverse_core.memory.schema import (
    KnowledgeSchema,
    Pinnable,
    Retention,
    Sensitivity,
)

reg.register(
    KnowledgeSchema(
        kind="my_session_view",
        retention=Retention.EPHEMERAL_SESSION,
        sensitivity=Sensitivity.TENANT_PRIVATE,
        pinnable_by=Pinnable.NOBODY,  # required: schema gates other values
        provenance_required=False,
    )
)

# Get memory stats for tenant
stats = memory_acme.get_memory_stats(
    tenant_id="acme_corp",
    agent_name="video_search_agent"
)

print(f"Tenant: acme_corp")
print(f"  Total Memories: {stats['total_memories']}")
print(f"  Enabled: {stats['enabled']}")
print(f"  Tenant ID: {stats.get('tenant_id', 'N/A')}")
print(f"  Agent: {stats.get('agent_name', 'N/A')}")

from cogniverse_foundation.config.unified_config import SystemConfig
from cogniverse_foundation.config.utils import create_default_config_manager

config_manager = create_default_config_manager()

# Define configuration templates
# Note: SystemConfig has basic system-level settings
# For advanced features (cache TTL, optimization), use RoutingConfigUnified
TENANT_TEMPLATES = {
    "enterprise": {
        "llm_model": "mistral:7b-instruct",
        "backend_url": "http://localhost",
        "backend_port": 8080,
        "telemetry_url": "http://localhost:6006"
    },
    "startup": {
        "llm_model": "openai/google/gemma-4-e4b-it",
        "backend_url": "http://localhost",
        "backend_port": 8080,
        "telemetry_url": "http://localhost:6006"
    },
    "trial": {
        "llm_model": "openai/google/gemma-4-e4b-it",
        "backend_url": "http://localhost",
        "backend_port": 8080,
        "telemetry_url": "http://localhost:6006"
    }
}

# Apply template to new tenant
def create_tenant_from_template(
    tenant_id: str,
    template: str = "enterprise",
    overrides: dict = None
):
    """Create tenant with template configuration"""

    # Get template
    template_config = TENANT_TEMPLATES[template].copy()

    # Apply overrides
    if overrides:
        template_config.update(overrides)

    # Create global system config from template (SystemConfig has no tenant_id)
    config = SystemConfig(**template_config)

    config_manager.set_system_config(config)
    print(f"✅ System config applied from {template} template")

# Usage
create_tenant_from_template(
    tenant_id="new_startup",
    template="startup",
    overrides={"llm_model": "google/gemma-4-e4b-it"}  # Custom override
)

from cogniverse_foundation.config.utils import create_default_config_manager
from cogniverse_sdk.interfaces.config_store import ConfigScope

config_manager = create_default_config_manager()

# Rollback global system configuration using version history
# SystemConfig is stored under the "_system" sentinel tenant — not per-tenant.
def rollback_system_config(version: int):
    """Rollback global system configuration to a specific version"""

    # Get config history (stored under "_system")
    entries = config_manager.store.get_config_history(
        tenant_id="_system",
        scope=ConfigScope.SYSTEM,
        service="system",
        config_key="system_config",
        limit=100
    )

    # Find target version
    target_entry = next((e for e in entries if e.version == version), None)
    if not target_entry:
        print(f"❌ Version {version} not found in system config history")
        return

    # Restore from target version
    from cogniverse_foundation.config.unified_config import SystemConfig
    old_config = SystemConfig.from_dict(target_entry.config_value)
    config_manager.set_system_config(old_config)

    print(f"✅ Rolled back system config to version {version}")

# Usage
rollback_system_config(version=5)

from pathlib import Path

from cogniverse_agents.search_agent import SearchAgent, SearchAgentDeps
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader
from cogniverse_foundation.config.utils import create_default_config_manager

config_manager = create_default_config_manager()


async def verify_tenant_isolation(tenant_a: str, tenant_b: str):
    """Verify complete isolation between two tenants"""

    checks = []

    # 1. Schema isolation
    # Note: Schema isolation is enforced by tenant-suffixed schema names
    # (see "Schema Naming Convention" above for the exact suffix rule —
    # it differs for a bare tenant_id vs an explicit org:tenant id).
    checks.append(("Schema Isolation", True))  # Enforced by design

    # 2. Data isolation (search)
    schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))
    agent = SearchAgent(
        deps=SearchAgentDeps(profile="video_colpali_smol500_mv_frame"),
        config_manager=config_manager,
        schema_loader=schema_loader,
    )
    results_a = agent.search_by_text(query="test query", tenant_id=tenant_a, top_k=100)  # synchronous
    # Verify tenant isolation by checking results are from correct tenant's schema
    checks.append(("Data Isolation", len(results_a) >= 0))  # Verify search works

    # 3. Memory isolation
    memory_a = Mem0MemoryManager(tenant_id=tenant_a)
    memories_a = memory_a.get_all_memories(tenant_id=tenant_a, agent_name="video_search_agent")
    checks.append(("Memory Isolation", len(memories_a) >= 0))  # Verify access works

    # 4. Configuration isolation (per-tenant routing configs are isolated)
    from cogniverse_foundation.config.utils import get_config
    config_a = get_config(tenant_id=tenant_a, config_manager=config_manager)
    config_b = get_config(tenant_id=tenant_b, config_manager=config_manager)
    checks.append(("Config Isolation", True))  # get_config scopes by tenant_id by design

    # Report
    print(f"\n🔒 Tenant Isolation Verification")
    print(f"   Tenant A: {tenant_a}")
    print(f"   Tenant B: {tenant_b}\n")

    all_passed = True
    for check_name, passed in checks:
        status = "✅" if passed else "❌"
        print(f"   {status} {check_name}")
        if not passed:
            all_passed = False

    return all_passed

# Run verification (in async context)
isolation_verified = await verify_tenant_isolation("acme_corp", "globex_inc")
assert isolation_verified, "Tenant isolation verification failed!"

from cogniverse_agents.search_agent import SearchAgent, SearchAgentDeps
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader
from pathlib import Path

# Tenant access control decorator
def require_tenant_access(tenant_id: str):
    """Decorator to enforce tenant access control"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            # Verify caller has access to tenant
            caller_tenant = kwargs.get('caller_tenant_id')
            if caller_tenant != tenant_id:
                raise PermissionError(
                    f"Caller {caller_tenant} not authorized for tenant {tenant_id}"
                )
            return func(*args, **kwargs)
        return wrapper
    return decorator

# Usage
@require_tenant_access("acme_corp")
def search_acme_videos(query: str, caller_tenant_id: str, config_manager):
    """Search restricted to acme_corp tenant"""
    schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))
    agent = SearchAgent(
        deps=SearchAgentDeps(profile="video_colpali_smol500_mv_frame"),
        config_manager=config_manager,
        schema_loader=schema_loader,
    )
    return agent.search_by_text(query=query, tenant_id="acme_corp")  # synchronous (not async)

import requests

# Submit an optimization run for a specific tenant
def trigger_tenant_optimization(tenant_id: str, mode: str = "gateway-thresholds"):
    response = requests.post(
        f"http://localhost:8000/admin/tenant/{tenant_id}/optimize",
        json={"mode": mode},
    )
    result = response.json()
    print(f"Workflow submitted: {result['workflow_name']}")
    print(f"Track progress: {result['status_url']}")
    return result

# Available modes: gateway-thresholds, simba, workflow, profile, entity-extraction
# (synthetic-data generation runs on its own scheduled CronWorkflow, not
# through this on-demand endpoint)
trigger_tenant_optimization("acme_corp", mode="gateway-thresholds")

from cogniverse_core.common.tenant_utils import canonical_tenant_id


# Check if tenant schemas exist
def diagnose_tenant_schemas(tenant_id: str):
    """Diagnose tenant schema issues"""

    print(f"Diagnosing schemas for: {tenant_id}\n")

    # A naive f"{base}_{tenant_id}" is wrong for BOTH a bare tenant_id
    # (canonicalization doubles it: "acme" -> "acme:acme" -> suffix
    # "acme_acme") and an org:tenant id (the literal ":" isn't a valid
    # Vespa schema-name character). Mirror the real
    # VespaSchemaManager.get_tenant_schema_name suffix logic instead.
    suffix = canonical_tenant_id(tenant_id).replace(":", "_")
    expected_schemas = [
        f"video_colpali_smol500_mv_frame_{suffix}",
        f"video_xclip_sv_chunk_6s_{suffix}",
    ]

    print(f"Expected schemas for {tenant_id}:")
    for schema in expected_schemas:
        print(f"   - {schema}")
        # To verify: curl http://localhost:8080/document/v1/{schema}/...

    print(
        f"\n   To deploy, POST /admin/profiles/<profile>/deploy with "
        f"tenant_id={tenant_id} against the runtime."
    )

# Usage
diagnose_tenant_schemas("acme:production")

from cogniverse_foundation.config.utils import create_default_config_manager

config_manager = create_default_config_manager()


# Check global system configuration and per-tenant routing config
def diagnose_tenant_config(tenant_id: str):
    """Diagnose tenant configuration issues"""

    print(f"Diagnosing configuration for: {tenant_id}\n")

    # Global system config (no tenant_id argument)
    system_config = config_manager.get_system_config()
    print(f"✅ Global system configuration:")
    print(f"   LLM Model: {system_config.llm_model}")
    print(f"   Telemetry URL: {system_config.telemetry_url}")
    print(f"   Backend URL: {system_config.backend_url}")

    # Per-tenant routing config. get_routing_config() NEVER raises for a
    # missing tenant — it silently returns RoutingConfigUnified(tenant_id=...)
    # defaults (see ConfigManager.get_routing_config), so a try/except around
    # it can't detect "missing". Query the store directly instead: it
    # returns None when no entry has ever been written for this tenant.
    # Canonicalize first — get/set_routing_config store under the
    # canonical org:tenant form, not necessarily what the caller passed.
    from cogniverse_core.common.tenant_utils import canonical_tenant_id
    from cogniverse_sdk.interfaces.config_store import ConfigScope

    entry = config_manager.store.get_config(
        tenant_id=canonical_tenant_id(tenant_id),
        scope=ConfigScope.ROUTING,
        service="gateway_agent",
        config_key="routing_config",
    )
    if entry is not None:
        print(f"✅ Per-tenant routing configuration found for {tenant_id}")
    else:
        print(f"❌ No per-tenant routing config stored for {tenant_id} (defaults are in effect)")
        print(f"   Run: config_manager.set_routing_config(RoutingConfigUnified(tenant_id='{tenant_id}'), tenant_id='{tenant_id}')")

# Usage
diagnose_tenant_config("acme_corp")

from cogniverse_agents.search_agent import SearchAgent, SearchAgentDeps
from cogniverse_foundation.config.utils import create_default_config_manager
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader
from pathlib import Path

config_manager = create_default_config_manager()
schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))

# ✅ Good: Profile set via deps, tenant_id at search time
agent = SearchAgent(
    deps=SearchAgentDeps(profile="video_colpali_smol500_mv_frame"),
    config_manager=config_manager,
    schema_loader=schema_loader,
)
results = agent.search_by_text(
    query="machine learning",
    tenant_id="acme_corp",
    top_k=10,
)

from cogniverse_agents.search_agent import SearchAgent, SearchAgentDeps
from cogniverse_foundation.config.utils import create_default_config_manager
from cogniverse_core.schemas.filesystem_loader import FilesystemSchemaLoader
from pathlib import Path

config_manager = create_default_config_manager()
schema_loader = FilesystemSchemaLoader(Path("configs/schemas"))

# One agent instance serves ALL tenants
agent = SearchAgent(
    deps=SearchAgentDeps(profile="video_colpali_smol500_mv_frame"),
    config_manager=config_manager,
    schema_loader=schema_loader,
)

# Search as tenant A
results_a = agent.search_by_text(
    query="test query",
    tenant_id="tenant_a",
    top_k=10,
)

# Search as tenant B — completely isolated schemas
results_b = agent.search_by_text(
    query="test query",
    tenant_id="tenant_b",
    top_k=10,
)

# No cross-tenant leakage — each tenant has its own Vespa schemas

from cogniverse_core.memory.manager import Mem0MemoryManager
from cogniverse_foundation.config.utils import create_default_config_manager

config_manager = create_default_config_manager()


# Regular tenant health checks
async def monitor_tenant_health(tenant_id: str):
    """Monitor tenant health metrics"""

    # Check per-tenant routing config existence. get_config()/
    # get_routing_config() never raise for a missing tenant — they
    # silently return defaults — so query the store directly (returns
    # None when nothing has been written for this tenant). Canonicalize
    # first — set_routing_config stores under the canonical org:tenant form.
    from cogniverse_core.common.tenant_utils import canonical_tenant_id
    from cogniverse_sdk.interfaces.config_store import ConfigScope

    entry = config_manager.store.get_config(
        tenant_id=canonical_tenant_id(tenant_id),
        scope=ConfigScope.ROUTING,
        service="gateway_agent",
        config_key="routing_config",
    )
    has_config = entry is not None

    # Check if tenant has memory manager instance
    has_memory = tenant_id in Mem0MemoryManager._instances

    health = {
        "schemas": 0,  # Would need schema_manager.list_schemas() if available
        "config": has_config,
        "memory_initialized": has_memory,
        "telemetry_project": tenant_id
    }

    # Alert if any health check fails
    if health["schemas"] == 0:
        alert(f"Tenant {tenant_id}: No schemas deployed")

    if not health["config"]:
        alert(f"Tenant {tenant_id}: Configuration missing")

    return health

# Example: Enforce tenant quotas (custom implementation required)
# Note: TenantQuotaManager is not part of the core framework
# This is a reference implementation pattern for production deployments

from typing import Dict, Any

class TenantQuotaManager:
    """
    Custom quota manager for multi-tenant deployments.

    Note: This is a reference implementation. Quotas should be implemented
    at the application or infrastructure layer based on your requirements.
    """

    def __init__(self, tenant_id: str):
        self.tenant_id = tenant_id
        self.quotas = self._load_quotas()

    async def check_quota(self, resource: str, amount: int = 1):
        """Check if tenant has quota for resource"""

        current_usage = await self._get_usage(resource)
        max_quota = self.quotas.get(resource, float('inf'))

        if current_usage + amount > max_quota:
            raise Exception(
                f"Tenant {self.tenant_id} exceeded {resource} quota "
                f"(current: {current_usage}, max: {max_quota})"
            )

        return True

    def _load_quotas(self) -> Dict[str, int]:
        """Load quota configuration for tenant"""
        # Implementation: Load from config store or database
        return {
            "api_calls": 10000,
            "storage_mb": 1000,
            "concurrent_requests": 10
        }

    async def _get_usage(self, resource: str) -> int:
        """Get current usage for resource"""
        # Implementation: Query from telemetry or metrics store
        return 0  # Placeholder

# Usage (in async context)
quota_manager = TenantQuotaManager("acme_corp")
await quota_manager.check_quota("api_calls")
await quota_manager.check_quota("storage_mb", amount=100)