ltcai 8.9.0 → 9.1.0

package/latticeai/models/router.py

@@ -9,6 +9,7 @@ import io
 import json
 import os
 import re
+import threading
 import time
 from dataclasses import dataclass
 from pathlib import Path
@@ -21,6 +22,15 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import AsyncIterator, Dict, Optional, Tuple, List
 from PIL import Image
 
+# Cloud provider catalog data lives in .model_providers; re-exported here so
+# ``from latticeai.models.router import OPENAI_COMPATIBLE_PROVIDERS`` (and the
+# model_runtime re-export chain) resolve unchanged after the split.
+from latticeai.models.model_providers import (  # noqa: F401
+    MODEL_SOURCE_BY_FAMILY,
+    OPENAI_COMPATIBLE_PROVIDERS,
+    PROVIDER_MODEL_CATALOG,
+)
+
 try:
     from openai import AsyncOpenAI
 except Exception:
@@ -76,108 +86,6 @@ def normalize_branding(text: Optional[str]) -> str:
         normalized = pattern.sub(replacement, normalized)
     return normalized
 
-OPENAI_COMPATIBLE_PROVIDERS = {
-    "openai": {
-        "env_key": "OPENAI_API_KEY",
-        "base_url_env": "OPENAI_BASE_URL",
-        "default_model": "gpt-4o-mini",
-    },
-    "openrouter": {
-        "env_key": "OPENROUTER_API_KEY",
-        "base_url": "https://openrouter.ai/api/v1",
-        "default_model": "openai/gpt-4o-mini",
-    },
-    "groq": {
-        "env_key": "GROQ_API_KEY",
-        "base_url": "https://api.groq.com/openai/v1",
-        "default_model": "meta-llama/llama-4-scout-17b-16e-instruct",
-    },
-    "together": {
-        "env_key": "TOGETHER_API_KEY",
-        "base_url": "https://api.together.xyz/v1",
-        "default_model": "Qwen/Qwen3-VL-32B-Instruct",
-    },
-    "xai": {
-        "env_key": "XAI_API_KEY",
-        "base_url": "https://api.x.ai/v1",
-        "default_model": "grok-beta",
-    },
-    "ollama": {
-        "env_key": "OLLAMA_API_KEY",
-        "base_url_env": "OLLAMA_BASE_URL",
-        "base_url": "http://localhost:11434/v1",
-        "default_model": "hf.co/ggml-org/gemma-4-12B-it-GGUF:Q4_K_M",
-        "api_key_fallback": "ollama",
-    },
-    "vllm": {
-        "env_key": "VLLM_API_KEY",
-        "base_url_env": "VLLM_BASE_URL",
-        "base_url": "http://localhost:8000/v1",
-        "default_model": "Qwen/Qwen3-VL-8B-Instruct",
-        "api_key_fallback": "vllm",
-    },
-    "lmstudio": {
-        "env_key": "LMSTUDIO_API_KEY",
-        "base_url_env": "LMSTUDIO_BASE_URL",
-        "base_url": "http://localhost:1234/v1",
-        "default_model": "local-model",
-        "api_key_fallback": "lmstudio",
-    },
-    "llamacpp": {
-        "env_key": "LLAMACPP_API_KEY",
-        "base_url_env": "LLAMACPP_BASE_URL",
-        "base_url": "http://localhost:8080/v1",
-        "default_model": "llama.cpp-model",
-        "api_key_fallback": "llamacpp",
-    },
-}
-
-PROVIDER_MODEL_CATALOG = {
-    "openai": [
-        {"id": "gpt-5.5", "name": "GPT-5.5", "family": "GPT"},
-        {"id": "gpt-5.4", "name": "GPT-5.4", "family": "GPT"},
-        {"id": "gpt-5.4-mini", "name": "GPT-5.4 Mini", "family": "GPT"},
-        {"id": "gpt-5.4-nano", "name": "GPT-5.4 Nano", "family": "GPT"},
-        {"id": "gpt-4o-mini", "name": "GPT-4o Mini", "family": "GPT"},
-        {"id": "gpt-4o", "name": "GPT-4o", "family": "GPT"},
-        {"id": "gpt-4.1-mini", "name": "GPT-4.1 Mini", "family": "GPT"},
-        {"id": "gpt-4.1", "name": "GPT-4.1", "family": "GPT"},
-    ],
-    "openrouter": [
-        {"id": "openai/gpt-5.5", "name": "GPT-5.5 via OpenRouter", "family": "GPT"},
-        {"id": "openai/gpt-4o-mini", "name": "GPT-4o Mini via OpenRouter", "family": "GPT"},
-        {"id": "anthropic/claude-opus-4.7", "name": "Claude Opus 4.7 via OpenRouter", "family": "Claude"},
-        {"id": "anthropic/claude-sonnet-4.6", "name": "Claude Sonnet 4.6 via OpenRouter", "family": "Claude"},
-        {"id": "anthropic/claude-haiku-4.5", "name": "Claude Haiku 4.5 via OpenRouter", "family": "Claude"},
-        {"id": "qwen/qwen3-vl-235b-a22b-instruct", "name": "Qwen3-VL 235B A22B via OpenRouter", "family": "Qwen"},
-        {"id": "google/gemma-4-12b-it", "name": "Gemma 4 12B via OpenRouter", "family": "Gemma"},
-        {"id": "x-ai/grok-2", "name": "Grok 2 via OpenRouter", "family": "Grok"},
-        {"id": "meta-llama/llama-4-scout-17b-16e-instruct", "name": "Llama 4 Scout via OpenRouter", "family": "Llama"},
-        {"id": "google/gemini-2.5-flash", "name": "Gemini 2.5 Flash via OpenRouter", "family": "Gemini"},
-    ],
-    "groq": [
-        {"id": "meta-llama/llama-4-scout-17b-16e-instruct", "name": "Llama 4 Scout", "family": "Llama"},
-    ],
-    "together": [
-        {"id": "Qwen/Qwen3-VL-32B-Instruct", "name": "Qwen3-VL 32B", "family": "Qwen"},
-        {"id": "google/gemma-4-12b-it", "name": "Gemma 4 12B", "family": "Gemma"},
-        {"id": "meta-llama/Llama-4-Scout-17B-16E-Instruct", "name": "Llama 4 Scout", "family": "Llama"},
-    ],
-    "xai": [
-        {"id": "grok-beta", "name": "Grok Beta", "family": "Grok"},
-        {"id": "grok-vision-beta", "name": "Grok Vision Beta", "family": "Grok"},
-    ],
-}
-
-MODEL_SOURCE_BY_FAMILY = {
-    "GPT": ("미국", "OpenAI"),
-    "Claude": ("미국", "Anthropic"),
-    "Qwen": ("중국", "Alibaba"),
-    "Llama": ("미국", "Meta"),
-    "Gemini": ("미국", "Google"),
-    "Grok": ("미국", "xAI"),
-}
-
 
 def source_metadata_for_model(provider: str, model: Dict[str, str], *, local_server: bool) -> Dict[str, str]:
     family = str(model.get("family") or "")
@@ -344,51 +252,64 @@ class LLMRouter:
         self._current: Optional[str] = None
         self._last_used: Dict[str, float] = {}
         self._max_local_models = max(1, int(os.getenv("LATTICEAI_MAX_LOCAL_MODELS", "1")))
+        # Guards the mutable model registry (_cache/_current/_last_used).
+        # Reentrant because the eviction path nests: _enforce_local_model_limit
+        # → unload_model → _release_memory. Never held across the heavy
+        # ``run_in_executor`` load (only the sync insert/read is guarded), so a
+        # long model load can't block a concurrent switch/unload from acquiring.
+        self._lock = threading.RLock()
 
     @property
     def current_model_id(self) -> Optional[str]:
-        return self._current
+        with self._lock:
+            return self._current
 
     @property
     def loaded_model_ids(self) -> List[str]:
-        return list(self._cache.keys())
+        with self._lock:
+            return list(self._cache.keys())
 
     def switch_model(self, model_id: str) -> None:
-        if model_id not in self._cache:
-            raise KeyError(model_id)
-        self._current = model_id
-        self._touch(model_id)
+        with self._lock:
+            if model_id not in self._cache:
+                raise KeyError(model_id)
+            self._current = model_id
+            self._touch(model_id)
 
     def unload_model(self, model_id: str) -> None:
-        self._cache.pop(model_id, None)
-        self._last_used.pop(model_id, None)
-        if self._current == model_id:
-            self._current = next(iter(self._cache), None)
-        self._release_memory()
+        with self._lock:
+            self._cache.pop(model_id, None)
+            self._last_used.pop(model_id, None)
+            if self._current == model_id:
+                self._current = next(iter(self._cache), None)
+            self._release_memory()
 
     def unload_all(self) -> None:
-        self._cache.clear()
-        self._last_used.clear()
-        self._current = None
-        self._release_memory()
+        with self._lock:
+            self._cache.clear()
+            self._last_used.clear()
+            self._current = None
+            self._release_memory()
 
     def unload_idle_models(self, idle_seconds: int) -> List[str]:
         if idle_seconds <= 0:
             return []
         now = time.monotonic()
         unloaded = []
-        for model_id, last_used in list(self._last_used.items()):
-            if now - last_used >= idle_seconds:
-                self.unload_model(model_id)
-                unloaded.append(model_id)
+        with self._lock:
+            for model_id, last_used in list(self._last_used.items()):
+                if now - last_used >= idle_seconds:
+                    self.unload_model(model_id)
+                    unloaded.append(model_id)
         return unloaded
 
     def model_memory_policy(self) -> Dict[str, object]:
-        return {
-            "max_local_models": self._max_local_models,
-            "loaded_count": len(self._cache),
-            "last_used": dict(self._last_used),
-        }
+        with self._lock:
+            return {
+                "max_local_models": self._max_local_models,
+                "loaded_count": len(self._cache),
+                "last_used": dict(self._last_used),
+            }
 
     def _touch(self, model_id: Optional[str] = None) -> None:
         model_id = model_id or self._current
@@ -400,14 +321,15 @@ class LLMRouter:
         return cached is not None and not isinstance(cached, CloudModel)
 
     def _enforce_local_model_limit(self, incoming_key: str) -> None:
-        local_ids = [model_id for model_id in self._cache if self._is_local_model(model_id)]
-        while len(local_ids) >= self._max_local_models:
-            victim = min(local_ids, key=lambda model_id: self._last_used.get(model_id, 0))
-            if victim == incoming_key:
-                break
-            print(f"🧹 Unloading local model to stay within memory policy: {victim}")
-            self.unload_model(victim)
+        with self._lock:
             local_ids = [model_id for model_id in self._cache if self._is_local_model(model_id)]
+            while len(local_ids) >= self._max_local_models:
+                victim = min(local_ids, key=lambda model_id: self._last_used.get(model_id, 0))
+                if victim == incoming_key:
+                    break
+                print(f"🧹 Unloading local model to stay within memory policy: {victim}")
+                self.unload_model(victim)
+                local_ids = [model_id for model_id in self._cache if self._is_local_model(model_id)]
 
     def _release_memory(self) -> None:
         gc.collect()
@@ -434,10 +356,11 @@ class LLMRouter:
             raise RuntimeError("MLX is not available in this process. Run on Apple Silicon with Metal access.")
 
         cache_key = f"{model_id}_{draft_model_id}" if draft_model_id else model_id
-        if cache_key in self._cache:
-            self._current = cache_key
-            self._touch(cache_key)
-            return f"Cached: {cache_key}"
+        with self._lock:
+            if cache_key in self._cache:
+                self._current = cache_key
+                self._touch(cache_key)
+                return f"Cached: {cache_key}"
 
         self._enforce_local_model_limit(cache_key)
         print(f"⏳ Loading local model stack: {cache_key}...")
@@ -479,9 +402,10 @@ class LLMRouter:
         try:
             # Use the dedicated single-thread executor to ensure MLX GPU streams match during inference
             model, tokenizer, draft_model, loader_kind = await loop.run_in_executor(executor, _load)
-            self._cache[cache_key] = (model, tokenizer, draft_model, loader_kind)
-            self._current = cache_key
-            self._touch(cache_key)
+            with self._lock:
+                self._cache[cache_key] = (model, tokenizer, draft_model, loader_kind)
+                self._current = cache_key
+                self._touch(cache_key)
             print(f"✅ Fully Loaded: {cache_key} ({loader_kind})")
             return f"Success: {cache_key} ({loader_kind})"
         except Exception as e:
@@ -507,9 +431,10 @@ class LLMRouter:
 
         cache_owner = owner or "global"
         cache_key = f"{provider}:{model}::{cache_owner}"
-        self._cache[cache_key] = CloudModel(provider=provider, model=model, client=AsyncOpenAI(**client_kwargs), cache_key=cache_key)
-        self._current = cache_key
-        self._touch(cache_key)
+        with self._lock:
+            self._cache[cache_key] = CloudModel(provider=provider, model=model, client=AsyncOpenAI(**client_kwargs), cache_key=cache_key)
+            self._current = cache_key
+            self._touch(cache_key)
         return f"Cloud provider ready: {cache_key}"
 
     def detected_cloud_models(self) -> List[Dict[str, str]]:
@@ -556,7 +481,8 @@ class LLMRouter:
         return items
 
     def _is_cloud_current(self) -> bool:
-        return bool(self._current and isinstance(self._cache.get(self._current), CloudModel))
+        with self._lock:
+            return bool(self._current and isinstance(self._cache.get(self._current), CloudModel))
 
     def _local_server_error_hint(self, cloud: CloudModel, error: Exception) -> str:
         raw = str(error)
@@ -610,28 +536,62 @@ class LLMRouter:
         loader_kind = str(cached[3]) if len(cached) > 3 else "mlx_vlm"
         return model, tokenizer, draft_model, loader_kind
 
-    async def generate_as(self, model_id: str | None, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2) -> str:
-        """Generate using a specific model, temporarily switching if needed. Falls back to current model if model_id is None or not loaded."""
-        if not model_id or model_id == self._current:
-            return await self.generate(message, context, max_tokens, temperature)
-        if model_id not in self._cache:
-            raise ValueError(f"Model '{model_id}' is not loaded. Load it first via /models/load.")
-        prev = self._current
-        self._current = model_id
-        try:
-            return await self.generate(message, context, max_tokens, temperature)
-        finally:
-            self._current = prev
-
-    async def generate(self, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2, image_data: Optional[str] = None) -> str:
-        if not self._current:
+    def _model_snapshot(self, model_id: Optional[str] = None) -> tuple[Optional[str], object | None]:
+        """Return an immutable request-scoped view of a loaded model.
+
+        Generation must never change ``_current``: that value is a UI/default
+        preference shared by every request.  Capturing the cache entry while
+        holding the registry lock prevents concurrent requests from selecting
+        or restoring each other's models.
+        """
+        with self._lock:
+            selected = model_id or self._current
+            if not selected:
+                return None, None
+            cached = self._cache.get(selected)
+            if cached is None:
+                raise ValueError(f"Model '{selected}' is not loaded. Load it first via /models/load.")
+            self._touch(selected)
+            return selected, cached
+
+    async def generate_as(
+        self,
+        model_id: str | None,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> str:
+        """Generate with a request-scoped model without changing the default."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             return "No model."
-        self._touch()
-        cached = self._cache[self._current]
+        return await self._generate_cached(cached, message, context, max_tokens, temperature, image_data)
+
+    async def generate(
+        self,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> str:
+        return await self.generate_as(None, message, context, max_tokens, temperature, image_data)
+
+    async def _generate_cached(
+        self,
+        cached: object,
+        message: str,
+        context: Optional[str],
+        max_tokens: int,
+        temperature: float,
+        image_data: Optional[str],
+    ) -> str:
         if isinstance(cached, CloudModel):
             return await self._cloud_generate(cached, message, context, max_tokens, temperature)
 
-        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(self._cache[self._current])
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         use_vlm = loader_kind == "mlx_vlm"
         prompt = (
             self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
@@ -674,18 +634,26 @@ class LLMRouter:
             raise RuntimeError(self._local_server_error_hint(cloud, e)) from e
         return normalize_branding(response.choices[0].message.content or "")
 
-    async def stream_generate(self, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2, image_data: Optional[str] = None) -> AsyncIterator[str]:
-        if not self._current:
+    async def stream_generate_as(
+        self,
+        model_id: str | None,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        """Stream with a request-scoped model without changing the default."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             yield "No model."
             return
-        self._touch()
-        cached = self._cache[self._current]
         if isinstance(cached, CloudModel):
             async for chunk in self._cloud_stream_generate(cached, message, context, max_tokens, temperature):
                 yield chunk
             return
 
-        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(self._cache[self._current])
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         use_vlm = loader_kind == "mlx_vlm"
         prompt = (
             self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
@@ -721,6 +689,19 @@ class LLMRouter:
                 break
             yield normalize_branding(chunk)
 
+    async def stream_generate(
+        self,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        async for chunk in self.stream_generate_as(
+            None, message, context, max_tokens, temperature, image_data
+        ):
+            yield chunk
+
     async def _cloud_stream_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float) -> AsyncIterator[str]:
         system = SYSTEM_PROMPT
         context = normalize_branding(context)
@@ -769,10 +750,27 @@ class LLMRouter:
         temperature: float = 0.3,
     ) -> str:
         """Generate a document using a specialized system prompt with graph context."""
-        if not self._current:
+        return await self.generate_document_as(
+            None,
+            message,
+            system_prompt,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+
+    async def generate_document_as(
+        self,
+        model_id: str | None,
+        message: str,
+        system_prompt: str,
+        *,
+        max_tokens: int = 8192,
+        temperature: float = 0.3,
+    ) -> str:
+        """Generate a document with a request-scoped model."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             return "No model loaded."
-        self._touch()
-        cached = self._cache[self._current]
 
         if isinstance(cached, CloudModel):
             return await self._cloud_generate_document(cached, message, system_prompt, max_tokens, temperature)
@@ -828,11 +826,29 @@ class LLMRouter:
         temperature: float = 0.3,
     ) -> AsyncIterator[str]:
         """Stream document generation with specialized system prompt."""
-        if not self._current:
+        async for chunk in self.stream_generate_document_as(
+            None,
+            message,
+            system_prompt,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        ):
+            yield chunk
+
+    async def stream_generate_document_as(
+        self,
+        model_id: str | None,
+        message: str,
+        system_prompt: str,
+        *,
+        max_tokens: int = 8192,
+        temperature: float = 0.3,
+    ) -> AsyncIterator[str]:
+        """Stream a document with a request-scoped model."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             yield "No model loaded."
             return
-        self._touch()
-        cached = self._cache[self._current]
 
         if isinstance(cached, CloudModel):
             async for chunk in self._cloud_stream_document(cached, message, system_prompt, max_tokens, temperature):

package/latticeai/runtime/access_runtime.py

@@ -20,9 +20,23 @@ def build_access_runtime(
     from latticeai.core.policy import normalize_role, require_capability
     from latticeai.core.users import normalize_email
 
+    # The historical loopback/no-auth profile represents its single human as
+    # an empty identity.  Keep that storage/workspace compatibility contract,
+    # but project the identity as an owner at authorization boundaries.  Never
+    # extend this trust to public or non-loopback bindings, even if an invalid
+    # caller constructs this runtime with ``require_auth=False`` directly.
+    externally_reachable = bool(
+        getattr(config, "is_public", False)
+        or getattr(config, "network_exposed", False)
+    )
+    trusted_local_owner = not require_auth and not externally_reachable
+    effective_require_auth = bool(require_auth or externally_reachable)
+
     def get_user_role(email: str, users: Optional[Dict] = None) -> str:
         users = users or load_users()
         identity = str(email or "")
+        if trusted_local_owner and not identity:
+            return "owner"
         normalized_email = normalize_email(identity)
         user = users.get(normalized_email) or users.get(identity) or next(
             (
@@ -46,25 +60,69 @@ def build_access_runtime(
             return auth[7:].strip()
         return request.cookies.get("session_token")
 
+    def active_session_email(identity: Optional[str], users: Dict) -> Optional[str]:
+        """Resolve a session identity only while its account remains active."""
+        if not identity:
+            return None
+        raw_identity = str(identity)
+        normalized_email = normalize_email(raw_identity)
+        matched_key: Optional[str] = None
+        user = users.get(normalized_email)
+        if isinstance(user, dict):
+            matched_key = normalized_email
+        else:
+            user = users.get(raw_identity)
+            if isinstance(user, dict):
+                matched_key = raw_identity
+            else:
+                for key, item in users.items():
+                    if isinstance(item, dict) and item.get("id") == raw_identity:
+                        matched_key = str(key)
+                        user = item
+                        break
+        # A session for a deleted account, malformed account record, or an
+        # explicitly disabled account is invalid immediately. This check is
+        # intentionally performed on every request so stale bearer/cookie
+        # tokens cannot retain user or administrator access.
+        if not matched_key or not isinstance(user, dict) or bool(user.get("disabled", False)):
+            return None
+        return normalize_email(matched_key)
+
     def get_current_user(request: request_type) -> Optional[str]:
         token = extract_bearer_token(request)
         if token:
-            return get_session_email(token)
+            try:
+                return active_session_email(get_session_email(token), load_users())
+            except Exception:
+                # Account-store failures must fail closed rather than turning a
+                # stale session into an authenticated identity.
+                return None
         return None
 
     def require_user(request: request_type) -> str:
         email = get_current_user(request)
-        if require_auth and not email:
+        if email:
+            # Optional authentication remains meaningful in local mode: a
+            # valid session keeps its real account identity instead of being
+            # collapsed into the anonymous Local User fallback.
+            return email
+        if trusted_local_owner:
+            # A no-auth loopback caller is the trusted, anonymous local owner.
+            # Returning the legacy empty identity keeps ownerless workspaces,
+            # shared local vaults, and Local User profile behavior compatible;
+            # get_user_role() supplies the explicit owner authorization role.
+            return ""
+        if effective_require_auth and not email:
             raise http_exception(status_code=401, detail="인증이 필요합니다.")
         return email or ""
 
     def require_admin(request: request_type) -> tuple[str, Dict]:
         users = load_users()
-        if not require_auth:
+        if trusted_local_owner:
             return "", users
         token = extract_bearer_token(request)
         if token:
-            email = get_session_email(token)
+            email = active_session_email(get_session_email(token), users)
             if email:
                 role = get_user_role(email, users)
                 try:

package/latticeai/runtime/audit_runtime.py

@@ -5,10 +5,11 @@ Returns dict of get_audit_log / append_audit_event for legacy namespace.
 from __future__ import annotations
 
 import json
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
+from latticeai.core import timezones
+
 
 def build_audit_runtime(
     *,
@@ -17,18 +18,33 @@ def build_audit_runtime(
     redact_fn: Optional[Callable[[str], str]] = None,
 ) -> Dict[str, Any]:
     _audit_lock: Any = __import__("threading").Lock()
+    audit_jsonl = audit_file.with_suffix(audit_file.suffix + ".jsonl")
 
     def _read_audit() -> List[Dict[str, Any]]:
+        events: List[Dict[str, Any]] = []
         if not audit_file.exists():
-            return []
-        try:
-            data = json.loads(audit_file.read_text(encoding="utf-8"))
-            return data if isinstance(data, list) else []
-        except Exception:
-            return []
+            data = []
+        else:
+            try:
+                data = json.loads(audit_file.read_text(encoding="utf-8"))
+            except Exception:
+                data = []
+        if isinstance(data, list):
+            events.extend(item for item in data if isinstance(item, dict))
+        if audit_jsonl.exists():
+            try:
+                for line in audit_jsonl.read_text(encoding="utf-8").splitlines():
+                    if not line.strip():
+                        continue
+                    item = json.loads(line)
+                    if isinstance(item, dict):
+                        events.append(item)
+            except Exception:
+                pass
+        return events[-5000:]
 
     def _append(event_type: str, **payload: Any) -> None:
-        entry = {"event_type": event_type, "timestamp": datetime.now().isoformat()}
+        entry = {"event_type": event_type, "timestamp": timezones.now_iso()}
         if payload:
             entry.update(payload)
         if redact_fn:
@@ -39,15 +55,10 @@ def build_audit_runtime(
             except Exception:
                 pass
         with _audit_lock:
-            events = _read_audit()
-            events.append(entry)
-            # keep last N to bound size (legacy behavior)
-            if len(events) > 5000:
-                events = events[-5000:]
             audit_file.parent.mkdir(parents=True, exist_ok=True)
-            tmp = audit_file.with_suffix(".tmp")
-            tmp.write_text(json.dumps(events, ensure_ascii=False, indent=2), encoding="utf-8")
-            tmp.replace(audit_file)
+            with audit_jsonl.open("a", encoding="utf-8") as fh:
+                fh.write(json.dumps(entry, ensure_ascii=False, default=str))
+                fh.write("\n")
 
     def get_audit_log() -> List[Dict[str, Any]]:
         return _read_audit()