loreguard-cli 0.12.2__tar.gz → 0.14.0rc1__tar.gz

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/.github/workflows/release.yml

@@ -7,8 +7,21 @@ on:
   workflow_dispatch:
 
 jobs:
-  build-windows:
-    runs-on: windows-latest
+  build:
+    strategy:
+      matrix:
+        include:
+          - os: windows-latest
+            artifact-name: loreguard-windows-amd64.exe
+            build-output: dist/loreguard.exe
+          - os: macos-latest
+            artifact-name: loreguard-darwin-arm64
+            build-output: dist/loreguard
+          - os: ubuntu-latest
+            artifact-name: loreguard-linux-amd64
+            build-output: dist/loreguard
+
+    runs-on: ${{ matrix.os }}
 
     steps:
       - uses: actions/checkout@v4
@@ -26,30 +39,37 @@ jobs:
       - name: Build with PyInstaller
         run: python scripts/build.py
 
+      - name: Rename artifact
+        shell: bash
+        run: mv ${{ matrix.build-output }} dist/${{ matrix.artifact-name }}
+
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: loreguard-windows.exe
-          path: dist/loreguard.exe
+          name: ${{ matrix.artifact-name }}
+          path: dist/${{ matrix.artifact-name }}
 
   release:
-    needs: build-windows
+    needs: build
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
     permissions:
       contents: write
 
     steps:
-      - name: Download Windows artifact
+      - name: Download all artifacts
         uses: actions/download-artifact@v4
         with:
-          name: loreguard-windows.exe
           path: artifacts
+          merge-multiple: true
 
       - name: Create Release
         uses: softprops/action-gh-release@v1
         with:
-          files: artifacts/loreguard.exe
+          files: |
+            artifacts/loreguard-windows-amd64.exe
+            artifacts/loreguard-darwin-arm64
+            artifacts/loreguard-linux-amd64
           generate_release_notes: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loreguard-cli
-Version: 0.12.2
+Version: 0.14.0rc1
 Summary: Local inference client for Loreguard NPCs
 Project-URL: Homepage, https://loreguard.com
 Project-URL: Documentation, https://github.com/beyond-logic-labs/loreguard-cli#readme

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "loreguard-cli"
-version = "0.12.2"
+version = "0.14.0-rc.1"
 description = "Local inference client for Loreguard NPCs"
 readme = "README.md"
 license = "MIT"

loreguard_cli-0.14.0rc1/sdk/API.md

@@ -0,0 +1,249 @@
+# Loreguard Client API Reference
+
+Loreguard Client exposes a local HTTP API that any game can call. The server runs on `127.0.0.1` with a dynamic port written to `runtime.json`.
+
+## Service Discovery
+
+On startup, loreguard-client writes a `runtime.json` file:
+
+| Platform | Path |
+|----------|------|
+| macOS | `~/Library/Application Support/loreguard/runtime.json` |
+| Linux | `~/.local/share/loreguard/runtime.json` (or `$XDG_DATA_HOME/loreguard/`) |
+| Windows | `%APPDATA%/loreguard/runtime.json` |
+
+```json
+{
+  "port": 52341,
+  "pid": 12345,
+  "url": "http://127.0.0.1:52341",
+  "started_at": "2026-02-20T10:30:00Z",
+  "version": "0.7.0",
+  "backend_connected": true
+}
+```
+
+Read this file to discover the port, then make HTTP calls to `http://127.0.0.1:{port}`.
+
+---
+
+## Endpoints
+
+### `GET /health`
+
+Check if loreguard-client is running and connected to the backend.
+
+**Response:**
+
+```json
+{
+  "status": "ok",
+  "backend_connected": true
+}
+```
+
+Returns `500` if the server is in an error state.
+
+---
+
+### `GET /api/capabilities`
+
+Discover what features this bundle supports. Use this to feature-detect before sending requests with optional fields.
+
+**Response:**
+
+```json
+{
+  "streaming": true,
+  "chunk_modes": ["deberta", "sentence"],
+  "manages_history": false
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `streaming` | bool | Whether SSE streaming is supported |
+| `chunk_modes` | string[] | Available chunk detection modes (e.g. `"deberta"`, `"sentence"`) |
+| `manages_history` | bool | Whether the bundle can manage conversation history internally |
+
+---
+
+### `POST /api/chat`
+
+Send a player message and get an NPC response. Supports both blocking JSON and SSE streaming.
+
+**Request Headers:**
+
+| Header | Value | Effect |
+|--------|-------|--------|
+| `Content-Type` | `application/json` | Required |
+| `Accept` | `text/event-stream` | Enables SSE streaming (optional) |
+| `Authorization` | `Bearer <token>` | API token for character access (optional) |
+
+**Request Body:**
+
+```json
+{
+  "character_id": "merchant-npc",
+  "message": "What do you have for sale?",
+  "player_handle": "player1",
+  "player_id": "uuid-here",
+  "current_context": "player is in the marketplace",
+  "scenario_id": "main-quest",
+  "history": [
+    {"role": "user", "content": "Hello!"},
+    {"role": "assistant", "content": "Welcome, traveler!"}
+  ],
+  "chunk_mode": "deberta",
+  "manage_history": false,
+  "max_speech_tokens": 150,
+  "verbose": false,
+  "enable_thinking": false
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `character_id` | string | Yes | NPC identifier |
+| `message` | string | Yes | Player's message |
+| `player_handle` | string | No | Player's display name |
+| `player_id` | string | No | Player's unique ID for per-player state. If empty, backend uses the developer's owner ID |
+| `current_context` | string | No | Game context (location, situation) |
+| `scenario_id` | string | No | Scenario identifier |
+| `history` | array | No | Conversation history. Omit if `manage_history` is true |
+| `chunk_mode` | string | No | `"deberta"` for ML-based chunk splitting, `"sentence"` for regex sentence splitting, `""` or omit for none |
+| `manage_history` | bool | No | If true, the backend manages conversation history per character+player pair |
+| `max_speech_tokens` | int | No | Maximum tokens in NPC speech (0 = default) |
+| `verbose` | bool | No | Include pipeline pass updates in response (for debugging) |
+| `enable_thinking` | bool | No | Include NPC internal monologue |
+
+All field names accept both `snake_case` and `camelCase` (e.g. `character_id` or `characterId`).
+
+#### JSON Response (default)
+
+When `Accept` is not `text/event-stream`:
+
+```json
+{
+  "response": "I have potions, swords, and shields. What interests you?",
+  "verified": true,
+  "citations": ["knowledge/inventory.md:5"],
+  "chunks": [
+    "I have potions, swords, and shields.",
+    "What interests you?"
+  ],
+  "pipeline_trace": []
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `response` | string | Full NPC speech |
+| `verified` | bool | Whether NeMo verification passed |
+| `citations` | string[] | Knowledge sources used |
+| `chunks` | string[] | Sentence/chunk boundaries (only present when `chunk_mode` was set) |
+| `pipeline_trace` | array | Pipeline pass details (only present when `verbose` was true) |
+
+#### SSE Streaming Response
+
+When `Accept: text/event-stream` is set, the response is a stream of Server-Sent Events:
+
+```
+event: filler
+data: {"text": "Hmm...", "dialogueAct": "wh-question"}
+
+event: pass_update
+data: {"pass": "retrieval", "status": "complete", "latencyMs": 120}
+
+event: token
+data: {"t": "I"}
+
+event: token
+data: {"t": " have"}
+
+event: token
+data: {"t": " potions"}
+
+event: done
+data: {"speech": "I have potions...", "verified": true, "citations": [...], "chunks": [...]}
+
+event: follow_up
+data: {"speech": "By the way, new stock arrives tomorrow.", ...}
+```
+
+| Event | Data | Description |
+|-------|------|-------------|
+| `filler` | `{text, dialogueAct}` | Contextual filler message. Sent early (~100ms) before the pipeline completes. Display immediately for perceived responsiveness |
+| `token` | `{t}` | Single token from the LLM. Append to build the response incrementally |
+| `pass_update` | `{pass, status, ...}` | Pipeline pass progress (only when `verbose` is true). For debugging |
+| `done` | `{speech, verified, citations, chunks, ...}` | Final verified response. Contains the same fields as the JSON response |
+| `follow_up` | `{speech, ...}` | Unsolicited follow-up message from the NPC (may arrive after `done`) |
+| `error` | `{error}` | Error message. Stream ends after this |
+
+---
+
+## Integration Patterns
+
+### Minimal (any language)
+
+Just POST JSON and read the response:
+
+```
+POST http://127.0.0.1:{port}/api/chat
+Content-Type: application/json
+
+{"character_id": "merchant", "message": "Hello!"}
+```
+
+### With Chunks (for staggered display)
+
+Request chunked responses and display each chunk separately with delays:
+
+```json
+{
+  "character_id": "merchant",
+  "message": "Hello!",
+  "chunk_mode": "deberta"
+}
+```
+
+Response includes `chunks` array. Display each chunk as a separate message/bubble with ~500-700ms delays between them.
+
+### With Server-Managed History
+
+Let the backend track conversation history so your game doesn't have to:
+
+```json
+{
+  "character_id": "merchant",
+  "message": "Hello!",
+  "player_id": "player-uuid",
+  "manage_history": true
+}
+```
+
+No `history` field needed. The backend maintains a rolling conversation buffer per `(character_id, player_id)` pair.
+
+### With Streaming + Filler
+
+For games with real-time UX (speech bubbles, typing indicators):
+
+1. Set `Accept: text/event-stream`
+2. On `filler` event: show typing indicator or filler text ("Hmm...")
+3. On `token` events: append tokens to display
+4. On `done` event: finalize the response, show verified status
+
+---
+
+## SDK Files
+
+Pre-built SDK files for common engines are in the `sdk/` directory. Copy the relevant file into your project:
+
+| Engine | File | Notes |
+|--------|------|-------|
+| Python | `sdk/python/loreguard_sdk.py` | Requires `httpx`. Async + sync support |
+| JavaScript / Electron | `sdk/javascript/loreguard-sdk.js` | Node.js CommonJS. Uses `fetch` |
+| Unity / C# | `sdk/csharp/LoreguardSDK.cs` | Uses `UnityWebRequest`. Coroutine-based |
+| Godot 4 | `sdk/gdscript/LoreguardSDK.gd` | Signal-based. Supports streaming |
+
+These are thin HTTP wrappers around the endpoints documented above. You can also call the API directly from any language that supports HTTP.

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/sdk/python/loreguard_sdk.py

@@ -145,7 +145,12 @@ async def chat(
     character_id: str,
     message: str,
     player_handle: str = "",
+    player_id: str = "",
     current_context: str = "",
+    history: list[dict[str, Any]] | None = None,
+    chunk_mode: str = "",
+    manage_history: bool = False,
+    max_speech_tokens: int = 0,
     stream: bool = True,
 ) -> AsyncIterator[dict[str, Any]]:
     """Chat with an NPC via loreguard-client.
@@ -154,12 +159,17 @@ async def chat(
         character_id: The NPC's ID
         message: Player's message to the NPC
         player_handle: Player's display name (optional)
+        player_id: Player's unique ID for per-player state (optional)
         current_context: Game context like "in a dark cave" (optional)
+        history: Conversation history as [{"role": "user"|"assistant", "content": "..."}] (optional)
+        chunk_mode: Chunk detection mode — "deberta" for ML-based, "" for none (optional)
+        manage_history: If True, bundle manages history internally per character+player (optional)
+        max_speech_tokens: Max tokens in NPC speech (optional, 0 = default)
         stream: If True, yields tokens as they arrive. If False, yields final response.
 
     Yields:
         For streaming: {"t": "token"} for each token, then {"speech": "...", "verified": True, ...}
-        For non-streaming: Single dict with complete response
+        For non-streaming: Single dict with complete response (includes "chunks" if chunk_mode set)
 
     Raises:
         RuntimeError: If loreguard-client is not running
@@ -181,12 +191,22 @@ async def chat(
     if stream:
         headers["Accept"] = "text/event-stream"
 
-    body = {
+    body: dict[str, Any] = {
         "character_id": character_id,
         "message": message,
         "player_handle": player_handle,
         "current_context": current_context,
     }
+    if player_id:
+        body["player_id"] = player_id
+    if history:
+        body["history"] = history
+    if chunk_mode:
+        body["chunk_mode"] = chunk_mode
+    if manage_history:
+        body["manage_history"] = True
+    if max_speech_tokens > 0:
+        body["max_speech_tokens"] = max_speech_tokens
 
     async with httpx.AsyncClient() as client:
         if stream:
@@ -214,6 +234,26 @@ async def chat(
             yield response.json()
 
 
+async def get_capabilities() -> dict[str, Any]:
+    """Get bundle capabilities.
+
+    Returns:
+        Capabilities dict with streaming, chunk_modes, manages_history.
+
+    Raises:
+        RuntimeError: If loreguard-client is not running
+        ImportError: If httpx is not installed
+    """
+    if httpx is None:
+        raise ImportError("httpx is required. Install with: pip install httpx")
+
+    url = f"{get_base_url()}/api/capabilities"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, timeout=5.0)
+        response.raise_for_status()
+        return response.json()
+
+
 async def health_check() -> dict[str, Any]:
     """Check loreguard-client health.
 
@@ -239,7 +279,12 @@ def chat_sync(
     character_id: str,
     message: str,
     player_handle: str = "",
+    player_id: str = "",
     current_context: str = "",
+    history: list[dict[str, Any]] | None = None,
+    chunk_mode: str = "",
+    manage_history: bool = False,
+    max_speech_tokens: int = 0,
 ) -> dict[str, Any]:
     """Synchronous chat (non-streaming).
 
@@ -247,17 +292,28 @@ def chat_sync(
 
     Returns:
         Complete response dict with speech, verified, citations, etc.
+        Includes "chunks" list if chunk_mode was set.
     """
     if httpx is None:
         raise ImportError("httpx is required. Install with: pip install httpx")
 
     url = f"{get_base_url()}/api/chat"
-    body = {
+    body: dict[str, Any] = {
         "character_id": character_id,
         "message": message,
         "player_handle": player_handle,
         "current_context": current_context,
     }
+    if player_id:
+        body["player_id"] = player_id
+    if history:
+        body["history"] = history
+    if chunk_mode:
+        body["chunk_mode"] = chunk_mode
+    if manage_history:
+        body["manage_history"] = True
+    if max_speech_tokens > 0:
+        body["max_speech_tokens"] = max_speech_tokens
 
     with httpx.Client() as client:
         response = client.post(url, json=body, timeout=120.0)

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/cli.py

@@ -240,12 +240,33 @@ class LoreguardCLI:
         try:
             llm_proxy = LLMProxy(f"http://127.0.0.1:{self.port}")
 
+            # ADR-0027: Load all ML services — the client is the sole provider
+            # of NLI, intent, dialogue act, and chunk capabilities.
+            # Use resolve_model_path() to prefer pre-shipped models (enterprise bundles).
+            from .config import resolve_model_path
+
+            # Initialize NLI service (HHEM grounding model)
+            nli_service = None
+            try:
+                from .nli import NLIService
+                nli_model = resolve_model_path("vectara/hallucination_evaluation_model", "hhem")
+                log.info(f"Loading NLI model ({nli_model})...")
+                nli_service = NLIService(model_path=nli_model)
+                if nli_service.load_model():
+                    log.info(f"NLI ready (device: {nli_service.device})")
+                else:
+                    log.warning("NLI model failed to load")
+                    nli_service = None
+            except Exception as e:
+                log.warning(f"NLI error: {e}")
+
             # Initialize intent classifier (ADR-0010)
             intent_classifier = None
             try:
                 from .intent_classifier import IntentClassifier
-                log.info("Loading intent classifier...")
-                intent_classifier = IntentClassifier()
+                intent_model = resolve_model_path("MoritzLaurer/DeBERTa-v3-large-zeroshot-v2.0", "deberta")
+                log.info(f"Loading intent classifier ({intent_model})...")
+                intent_classifier = IntentClassifier(model_path=intent_model)
                 if intent_classifier.load_model():
                     log.info(f"Intent classifier ready (device: {intent_classifier.device})")
                 else:
@@ -254,6 +275,26 @@ class LoreguardCLI:
             except Exception as e:
                 log.warning(f"Intent classifier error: {e}")
 
+            # Initialize dialogue act classifier
+            dialogue_act_classifier = None
+            try:
+                from .dialogue_act_classifier import (
+                    DialogueActClassifier,
+                    is_dialogue_act_model_available,
+                )
+                if is_dialogue_act_model_available():
+                    log.info("Loading dialogue act classifier...")
+                    dialogue_act_classifier = DialogueActClassifier()
+                    if dialogue_act_classifier.load_model():
+                        log.info(f"Dialogue act classifier ready (device: {dialogue_act_classifier.device})")
+                    else:
+                        log.warning("Dialogue act classifier failed to load")
+                        dialogue_act_classifier = None
+                else:
+                    log.info("Dialogue act model not available, skipping")
+            except Exception as e:
+                log.warning(f"Dialogue act classifier error: {e}")
+
             # Initialize chunk detector (ADR-0023) - shares model with intent classifier
             chunk_detector = None
             try:
@@ -278,7 +319,9 @@ class LoreguardCLI:
                 worker_id=self.worker_id,
                 worker_token=self.token,
                 model_id=self.model_path.stem if self.model_path else "unknown",
+                nli_service=nli_service,
                 intent_classifier=intent_classifier,
+                dialogue_act_classifier=dialogue_act_classifier,
                 chunk_detector=chunk_detector,
             )
 

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/config.py

@@ -152,9 +152,49 @@ def load_config() -> dict:
 
         # Context compaction: if True, truncate old messages instead of erroring
         "CONTEXT_COMPACTION": os.getenv("CONTEXT_COMPACTION", "true").lower() == "true",
+
+        # ADR-0027: Pre-shipped models directory for enterprise bundles.
+        # When set, model loaders check this directory first before downloading from HF.
+        # Expected subdirectories: hhem/, deberta/, distilbert/, llm/
+        "MODELS_DIR": os.getenv("LOREGUARD_MODELS_DIR", ""),
+
+        # Pre-shipped llama-server binary path (enterprise bundles).
+        # When set, skips auto-download and uses this binary directly.
+        "LLAMA_SERVER_PATH": os.getenv("LOREGUARD_LLAMA_SERVER_PATH", ""),
     }
 
 
+def get_models_dir() -> Optional[Path]:
+    """Get the pre-shipped models directory, if configured (ADR-0027).
+
+    Returns None if not set, meaning models should be auto-downloaded from HF.
+    """
+    models_dir = get_config_value("MODELS_DIR")
+    if models_dir:
+        path = Path(models_dir)
+        if path.exists() and path.is_dir():
+            return path
+    return None
+
+
+def resolve_model_path(model_name: str, subdir: str = "") -> str:
+    """Resolve a model path, preferring pre-shipped models over HF downloads.
+
+    Args:
+        model_name: HuggingFace model name (e.g., 'vectara/hallucination_evaluation_model')
+        subdir: Subdirectory within MODELS_DIR to check (e.g., 'hhem', 'deberta')
+
+    Returns:
+        Local path if pre-shipped model found, otherwise the original HF model name.
+    """
+    models_dir = get_models_dir()
+    if models_dir and subdir:
+        local_path = models_dir / subdir
+        if local_path.exists() and any(local_path.iterdir()):
+            return str(local_path)
+    return model_name
+
+
 def get_config_value(key: str, default: Optional[str] = None) -> Optional[str]:
     """Get a single configuration value."""
     config = load_config()

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/http_server.py

@@ -1,12 +1,18 @@
-"""Embedded HTTP server for game SDK connections.
+"""Embedded HTTP server for game SDK connections (ADR-0027).
 
-This module provides a lightweight HTTP server that can be started
-alongside the TUI or CLI to handle game client requests via SSE.
+This module provides the official SDK HTTP interface for games to interact
+with loreguard. Games discover this server via runtime.json and call its
+HTTP endpoints:
+
+  GET  /health            - Health check with backend connection status
+  GET  /api/capabilities  - Feature discovery (streaming, chunk modes)
+  GET  /api/characters    - List available NPCs (proxied from engine)
+  POST /api/chat          - Chat with an NPC (streaming SSE or JSON)
 
 The server shares the existing tunnel connection instead of creating
-a new one, ensuring a single WebSocket connection per player.
+a new one, ensuring a single WebSocket connection per worker.
 
-Uses hypercorn with socket-first binding for race-condition-free port allocation.
+Uses uvicorn with socket-first binding for race-condition-free port allocation.
 """
 
 import asyncio
@@ -266,6 +272,8 @@ class EmbeddedHTTPServer:
                         "verified": data.get("verified", False),
                         "citations": data.get("citations", []),
                     }
+                    if data.get("chunks"):
+                        result["chunks"] = data["chunks"]
                     if pipeline_trace:
                         result["pipeline_trace"] = pipeline_trace
                     return result
@@ -313,16 +321,78 @@ class EmbeddedHTTPServer:
         async def health():
             try:
                 backend_connected = server.tunnel.connected if server.tunnel else False
-                return {
+                result = {
                     "status": "ok",
                     "backend_connected": backend_connected,
                 }
+                # Include capabilities for game clients to check readiness
+                if server.tunnel and hasattr(server.tunnel, "capabilities"):
+                    result["capabilities"] = server.tunnel.capabilities
+                return result
             except Exception as e:
                 return JSONResponse(
                     status_code=500,
                     content={"status": "error", "error": str(e)},
                 )
 
+        @app.get("/api/capabilities")
+        async def capabilities():
+            caps = {
+                "streaming": True,
+                "chunk_modes": ["sentence"],
+                "manages_history": False,
+            }
+            if server.tunnel:
+                if getattr(server.tunnel, "chunk_detector", None) and server.tunnel.chunk_detector.is_loaded:
+                    caps["chunk_modes"].append("deberta")
+            return caps
+
+        @app.get("/api/characters")
+        async def characters(request: Request):
+            """Proxy character listing from the engine (ADR-0027).
+
+            Games discover NPCs through the client SDK, not by calling the engine directly.
+            """
+            if not server.tunnel or not server.tunnel.connected:
+                return JSONResponse(
+                    status_code=503,
+                    content={"error": "Not connected to backend. Start the engine first."},
+                )
+
+            # Derive HTTP base URL from WebSocket URL
+            # ws://localhost:8090/workers → http://localhost:8090
+            # wss://api.loreguard.com/workers → https://api.loreguard.com
+            backend_ws = server.tunnel.backend_url
+            if backend_ws.startswith("wss://"):
+                base_url = "https://" + backend_ws[6:].split("/")[0]
+            elif backend_ws.startswith("ws://"):
+                base_url = "http://" + backend_ws[5:].split("/")[0]
+            else:
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": f"Cannot derive HTTP URL from backend: {backend_ws}"},
+                )
+
+            try:
+                import httpx
+                # Forward Authorization header if present
+                headers = {}
+                auth_header = request.headers.get("authorization", "")
+                if auth_header:
+                    headers["Authorization"] = auth_header
+
+                async with httpx.AsyncClient(timeout=10.0) as client:
+                    resp = await client.get(f"{base_url}/api/characters", headers=headers)
+                    return JSONResponse(
+                        status_code=resp.status_code,
+                        content=resp.json(),
+                    )
+            except Exception as e:
+                return JSONResponse(
+                    status_code=502,
+                    content={"error": f"Failed to reach engine: {e}"},
+                )
+
         @app.post("/api/chat")
         async def chat(request: Request):
             if not server.tunnel or not server.tunnel.connected:
@@ -340,6 +410,8 @@ class EmbeddedHTTPServer:
             scenario_id = body.get("scenario_id", body.get("scenarioId", ""))
             enable_thinking = body.get("enable_thinking", body.get("enableThinking", False))
             max_speech_tokens = body.get("max_speech_tokens", body.get("maxSpeechTokens", 0))
+            chunk_mode = body.get("chunk_mode", body.get("chunkMode", ""))
+            manage_history = body.get("manage_history", body.get("manageHistory", False))
             accept = request.headers.get("accept", "")
             streaming = "text/event-stream" in accept
 
@@ -366,6 +438,8 @@ class EmbeddedHTTPServer:
                             verbose=body.get("verbose", False),
                             api_token=api_token,
                             max_speech_tokens=max_speech_tokens,
+                            chunk_mode=chunk_mode,
+                            manage_history=manage_history,
                         )
                     )
                     # Wait for the result
@@ -389,6 +463,8 @@ class EmbeddedHTTPServer:
                     verbose=body.get("verbose", False),
                     api_token=api_token,
                     max_speech_tokens=max_speech_tokens,
+                    chunk_mode=chunk_mode,
+                    manage_history=manage_history,
                 )
 
             if streaming:

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/llama_server.py

@@ -106,7 +106,18 @@ def get_slot_cache_dir() -> Path:
 
 
 def get_llama_server_path() -> Path:
-    """Get the path to llama-server binary."""
+    """Get the path to llama-server binary.
+
+    ADR-0027: Checks LOREGUARD_LLAMA_SERVER_PATH first for pre-shipped binaries
+    (enterprise bundles), then falls back to the default bin directory.
+    """
+    # Check for pre-shipped binary (enterprise bundle)
+    override = os.environ.get("LOREGUARD_LLAMA_SERVER_PATH", "")
+    if override:
+        p = Path(override)
+        if p.exists() and p.is_file():
+            return p
+
     plat = get_platform()
     binary_name = BINARIES[plat]["binary_name"]
     return get_bin_dir() / binary_name
@@ -129,7 +140,16 @@ def get_installed_version() -> Optional[str]:
 
 
 def is_llama_server_installed() -> bool:
-    """Check if llama-server is installed with the correct version."""
+    """Check if llama-server is installed with the correct version.
+
+    ADR-0027: If LOREGUARD_LLAMA_SERVER_PATH is set and the binary exists,
+    always returns True (pre-shipped binary, skip version check).
+    """
+    # Pre-shipped binary always counts as installed
+    override = os.environ.get("LOREGUARD_LLAMA_SERVER_PATH", "")
+    if override and Path(override).exists():
+        return True
+
     server_path = get_llama_server_path()
     if not (server_path.exists() and server_path.is_file()):
         return False

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/llm.py

@@ -572,25 +572,26 @@ class LLMProxy:
             payload["enable_thinking"] = False
 
         # Force JSON output if requested
-        # Use json_object type with schema field - this is supported in llama.cpp server
-        # (server-common.cpp extracts schema from response_format.schema for json_object type)
-        # Note: json_schema type has a bug (issue #10732, PR #18963 pending)
         if req.force_json:
-            # Merge system prompt into user message for "Content-only" template
-            if len(req.messages) >= 2 and req.messages[0].get("role") == "system":
-                system_content = req.messages[0]["content"]
-                user_content = req.messages[-1]["content"]
-                merged = f"INSTRUCTIONS:\n{system_content}\n\nREQUEST:\n{user_content}"
-                payload["messages"] = [{"role": "user", "content": merged}]
-                logger.debug("JSON MODE: Merged system into user message")
-
-            # Use json_object with schema for proper constraint enforcement
             if req.json_schema:
-                payload["response_format"] = {"type": "json_object", "schema": req.json_schema}
-                logger.info(f"JSON MODE: response_format=json_object with schema")
+                # Use top-level json_schema field for grammar-constrained JSON.
+                # This bypasses the chat template (which corrupts schemas on Llama 3.1
+                # by routing them through function-calling) and goes directly to GBNF
+                # grammar conversion.
+                payload["json_schema"] = req.json_schema
+                logger.info("JSON MODE: top-level json_schema for grammar constraint")
             else:
+                # Generic JSON object mode (no schema constraint).
+                # response_format changes chat template to "Content-only" which loses
+                # system prompt context, so merge system into user message.
+                if len(req.messages) >= 2 and req.messages[0].get("role") == "system":
+                    system_content = req.messages[0]["content"]
+                    user_content = req.messages[-1]["content"]
+                    merged = f"INSTRUCTIONS:\n{system_content}\n\nREQUEST:\n{user_content}"
+                    payload["messages"] = [{"role": "user", "content": merged}]
+                    logger.debug("JSON MODE: Merged system into user message")
                 payload["response_format"] = {"type": "json_object"}
-                logger.info(f"JSON MODE: response_format=json_object (no schema)")
+                logger.info("JSON MODE: response_format=json_object (no schema)")
 
         # Use per-request timeout if specified
         timeout = req.timeout or self.default_timeout

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/main.py

@@ -31,7 +31,7 @@ from rich.console import Console
 
 from .tunnel import BackendTunnel
 from .llm import LLMProxy
-from .config import get_config_value
+from .config import get_config_value, resolve_model_path
 from .nli import NLIService, is_nli_model_available
 from .intent_classifier import IntentClassifier, is_intent_model_available
 from .dialogue_act_classifier import (
@@ -91,7 +91,8 @@ async def startup():
     enable_nli = os.getenv("LOREGUARD_NLI_ENABLED", "true").lower() == "true"
     if enable_nli:
         console.print("[cyan]Initializing NLI service...[/cyan]")
-        nli_service = NLIService()
+        nli_model = resolve_model_path("vectara/hallucination_evaluation_model", "hhem")
+        nli_service = NLIService(model_path=nli_model)
         if nli_service.load_model():
             console.print(f"[green]NLI service ready (device: {nli_service.device})[/green]")
         else:
@@ -105,7 +106,8 @@ async def startup():
     enable_intent = os.getenv("LOREGUARD_INTENT_ENABLED", "true").lower() == "true"
     if enable_intent:
         console.print("[cyan]Initializing intent classifier...[/cyan]")
-        intent_classifier = IntentClassifier()
+        intent_model = resolve_model_path("MoritzLaurer/DeBERTa-v3-large-zeroshot-v2.0", "deberta")
+        intent_classifier = IntentClassifier(model_path=intent_model)
         if intent_classifier.load_model():
             console.print(f"[green]Intent classifier ready (device: {intent_classifier.device})[/green]")
         else:

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/tui/widgets/banner.py

@@ -5,6 +5,7 @@ from rich.text import Text
 from rich.style import Style
 
 from ..styles import FG_DIM, PINK
+from ...runtime import get_version
 
 # Simple stylized logo
 LOGO = r"""
@@ -43,9 +44,9 @@ class LoreguardBanner(Static):
     }
     """
 
-    def __init__(self, version: str = "0.11.0") -> None:
+    def __init__(self, version: str = None) -> None:
         super().__init__()
-        self._version = version
+        self._version = version or get_version()
 
     def render(self) -> Text:
         """Render minimal banner."""

{loreguard_cli-0.12.2 → loreguard_cli-0.14.0rc1}/src/tunnel.py

@@ -468,6 +468,7 @@ class BackendTunnel:
         elif msg_type == "pass_update":
             # Pipeline pass update (verbose mode)
             payload = data.get("payload", {})
+            self._log(f"[pass_update] received pass={payload.get('pass','?')} name={payload.get('name','?')}", "info")
             if self.on_pass_update:
                 self.on_pass_update(payload)
             # Also route to per-request queue for HTTP/SSE clients
@@ -1388,6 +1389,8 @@ class BackendTunnel:
         verbose: bool = False,
         api_token: str = "",
         max_speech_tokens: int = 0,
+        chunk_mode: str = "",
+        manage_history: bool = False,
     ) -> asyncio.Queue[dict[str, Any]]:
         """Send a chat request to the backend and return a queue for responses.
 
@@ -1434,6 +1437,10 @@ class BackendTunnel:
         # Only include maxSpeechTokens if explicitly set (non-zero)
         if max_speech_tokens > 0:
             payload["maxSpeechTokens"] = max_speech_tokens
+        if chunk_mode:
+            payload["chunkMode"] = chunk_mode
+        if manage_history:
+            payload["manageHistory"] = True
 
         await self._send({
             "id": self._generate_message_id(),
@@ -1498,6 +1505,7 @@ class BackendTunnel:
                 "type": "done",
                 "data": {
                     "speech": payload.get("speech", ""),
+                    "chunks": payload.get("chunks"),
                     "thoughts": payload.get("thoughts", ""),
                     "citations": payload.get("citations", []),
                     "verified": payload.get("verified", False),