@chatpanel/gateway 0.5.5 → 0.6.0

package/README.md

@@ -78,18 +78,24 @@ export OPENAI_BASE_URL=http://127.0.0.1:4320/v1     # OpenAI / codex / aider / c
 export ANTHROPIC_BASE_URL=http://127.0.0.1:4320     # Claude Code / Anthropic SDK
 ```
 
-## Name/org redaction is built in (bundled NER)
+## Name/org redaction is built in (in-process NER, no Python)
 
 Deterministic redaction (emails, phones, cards, SSNs, API keys, IPs) needs no
-setup. To also blind **names, organizations and locations**, the gateway bundles
-a local spaCy NER server under [`ner/`](ner) and — with `ner.autostart` on (the
-default) — **launches it for you on startup** and switches redaction to the
-`full` tier once it's healthy. First run creates a venv and downloads the model
-(needs `python3`); it's fail-open, so if Python isn't set up the gateway just runs
-deterministic-only.
-
-Prefer a local LLM or an external NER service? Set `redaction.detection` yourself
-and the gateway won't autostart the bundled one.
+setup. To also blind **names, organizations and locations**, the gateway runs an
+**in-process** entity detector — an ONNX transformer model via transformers.js —
+with `ner.autostart` on (the default). There's **no Python, no second port, no
+separate process**: the same model runs identically on macOS / Windows / Linux.
+The model loads from `~/.chatpanel/models` and is downloaded once on first run if
+absent (set `ner.allowDownload: false` to require it be pre-placed). It's
+fail-open, so if the model can't load the gateway just runs deterministic-only.
+Once the detector is ready, redaction switches to the `full` tier automatically.
+
+The default model (`Xenova/bert-base-NER`) matches or beats spaCy's small model on
+people/orgs/locations. Larger or alternative models can be installed from the
+ChatPanel extension's **Gateway** settings.
+
+Prefer a local LLM or your own external NER service? Set `redaction.detection`
+yourself and the gateway won't load the bundled one (yours takes precedence).
 
 ## Configuration
 
@@ -106,9 +112,11 @@ env vars. See [`gateway.config.example.json`](gateway.config.example.json).
 | `upstreams.openai.baseUrl` | `OPENAI_BASE_URL` | `https://api.openai.com` | api backend only |
 | `upstreams.anthropic.baseUrl` | `ANTHROPIC_BASE_URL` | `https://api.anthropic.com` | api backend only |
 | `redaction.tier` | `CHATPANEL_REDACTION_TIER` | `basic` | `basic` (regex) or `full` (+ NER + dictionary) |
-| `redaction.detection` | — | _(auto via NER)_ | local detector; set to override the bundled one |
+| `redaction.detection` | — | _(off → bundled engine)_ | external detector; set to override the bundled in-process one |
 | `redaction.dictionary` | — | `[]` | custom `{ value\|pattern, type, alias? }` entries |
-| `ner.autostart` / `ner.port` | — | `true` / `9009` | launch + wire the bundled spaCy NER |
+| `ner.autostart` | — | `true` | load the bundled in-process NER on startup |
+| `ner.model` | — | `Xenova/bert-base-NER` | model id under `~/.chatpanel/models` |
+| `ner.allowDownload` | — | `true` | download the model on first run if absent |
 
 ## Endpoints
 

package/bin/chatpanel-gateway-bin.mjs

@@ -0,0 +1,24 @@
+// Binary entry point for the Bun `--compile` standalone build (no Node required).
+//
+// A compiled single-file binary cannot embed onnxruntime-node's native dylib, so
+// NER runs on the onnxruntime-web WASM runtime instead. We embed that runtime's
+// two files INTO the executable here (Bun's `with { type: 'file' }` copies the
+// asset in and yields a runtime path to it), then hand their paths to the NER
+// engine via a global. src/ner-engine.js sees the global, forces the WASM backend,
+// and points ORT at these files. Everything else is the normal CLI.
+//
+// The npm/Node package uses bin/chatpanel-gateway.js instead, which keeps the
+// faster native onnxruntime-node runtime.
+
+import { pathToFileURL } from 'node:url';
+import wasmFile from '../assets/ort-wasm-simd-threaded.wasm' with { type: 'file' };
+import mjsFile from '../assets/ort-wasm-simd-threaded.mjs' with { type: 'file' };
+
+globalThis.__CHATPANEL_WASM_PATHS__ = {
+  wasm: pathToFileURL(wasmFile).href,
+  mjs: pathToFileURL(mjsFile).href,
+};
+
+// Delegate to the normal CLI (start / --install / --version / …). The global is
+// already set, so when the gateway starts NER the engine uses the embedded WASM.
+await import('./chatpanel-gateway.js');

package/gateway.config.example.json

@@ -25,7 +25,8 @@
 
   "ner": {
     "autostart": true,
-    "port": 9009,
+    "model": "Xenova/bert-base-NER",
+    "allowDownload": true,
     "enableFullTier": true
   },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "description": "Local privacy gateway — redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {
@@ -14,14 +14,11 @@
     "start": "node bin/chatpanel-gateway.js",
     "test": "node --test",
     "typecheck": "tsc -p tsconfig.json",
-    "build:bin": "bash scripts/build-binaries.sh",
-    "gen:ner": "node scripts/gen-ner-assets.mjs",
-    "prepublishOnly": "node scripts/gen-ner-assets.mjs"
+    "build:bin": "bash scripts/build-binaries.sh"
   },
   "files": [
     "src",
     "bin",
-    "ner",
     "gateway.config.example.json",
     "LICENSE",
     "README.md"
@@ -30,7 +27,9 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@chatpanel/pii": "^0.2.5"
+    "@chatpanel/pii": "^0.2.5",
+    "@huggingface/transformers": "^4.2.0",
+    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"
   },
   "homepage": "https://chatpanel.net",
   "repository": {

package/src/config.js

@@ -73,20 +73,24 @@ const DEFAULTS = {
     // Local entity detector, passed straight to pii-detect.detectEntities.
     //   backend: 'off' | 'endpoint' (POST {text}->{entities}) | 'openai' (local LLM)
     //   url, model, timeoutMs, maxChars
-    // When `ner.autostart` is on (below), the gateway launches the bundled spaCy
-    // NER server and points detection at it automatically — leave this `off`.
+    // Leave this `off` to use the bundled in-process NER (see `ner` below). Set it
+    // only to point at YOUR OWN external detector (a custom NER or local LLM); that
+    // takes precedence over the bundled engine.
     detection: { backend: 'off' },
     // Per-request convenience: also redact the system prompt / system blocks.
     redactSystem: true,
   },
-  // Bundled local NER server (spaCy). When autostart is on, `npm start` also
-  // launches ./ner on this port and wires `redaction.detection` to it, so name/
-  // org redaction works out of the box with one command. Fails open: if Python/
-  // spaCy isn't set up, the gateway logs a hint and runs deterministic-only.
+  // Bundled IN-PROCESS NER (ONNX via transformers.js). When autostart is on, the
+  // gateway loads the entity detector in-process — no Python, no second port — so
+  // name/org redaction works out of the box. The model loads from
+  // ~/.chatpanel/models and is downloaded once on first run if absent. Larger /
+  // alternative models can be installed from the extension's Gateway settings.
+  // Fails open: if the model can't load, the gateway runs deterministic-only.
   ner: {
     autostart: true,
-    port: 9009,
-    // Auto-bump redaction.tier to 'full' once NER is up (names/orgs need it).
+    model: 'Xenova/bert-base-NER',
+    allowDownload: true,
+    // Auto-bump redaction.tier to 'full' once the detector is ready (names/orgs).
     enableFullTier: true,
   },
 

package/src/models.js

@@ -0,0 +1,38 @@
+// Catalog of NER models the gateway can run, surfaced in the extension's Gateway
+// settings so users can install a larger or multilingual detector. All are ONNX
+// (transformers.js) token-classification models that emit PER/ORG/LOC — the only
+// labels the redaction engine consumes. Sizes are the on-disk q8 footprint, approx.
+//
+// Adding a model: any Xenova/* token-classification model whose labels map to
+// PER/ORG/LOC works (pii-detect normalizeEntities handles the label mapping).
+// Verify it loads + detects before listing it here.
+
+export const DEFAULT_MODEL = 'Xenova/bert-base-NER';
+
+export const MODEL_CATALOG = [
+  {
+    id: 'Xenova/bert-base-NER',
+    label: 'English — standard',
+    lang: 'English',
+    approxMB: 105,
+    note: 'Default. Best English accuracy for people, organizations, and locations.',
+  },
+  {
+    id: 'Xenova/distilbert-base-multilingual-cased-ner-hrl',
+    label: 'Multilingual — compact',
+    lang: '10 languages',
+    approxMB: 150,
+    note: 'Covers en, es, fr, de, it, pt, nl, ar, zh, ru. Use for non-English text.',
+  },
+  {
+    id: 'Xenova/bert-base-multilingual-cased-ner-hrl',
+    label: 'Multilingual — large',
+    lang: '10 languages',
+    approxMB: 180,
+    note: 'Higher multilingual accuracy; larger download.',
+  },
+];
+
+export function isKnownModel(id) {
+  return MODEL_CATALOG.some((m) => m.id === id);
+}

package/src/ner-engine.js

@@ -0,0 +1,225 @@
+// In-process Named Entity Recognition — zero Python, zero second port.
+//
+// Replaces the old bundled spaCy microservice (a Python venv + uvicorn on :9009)
+// with an ONNX transformer model run IN-PROCESS via transformers.js. This is what
+// makes the gateway self-contained: nothing to install, no interpreter, no second
+// port — the same model runs identically on macOS / Windows / Linux, and offline
+// once the weights are on disk.
+//
+// Accuracy: the default (Xenova/bert-base-NER) matches or beats spaCy's
+// en_core_web_sm on PERSON / ORG / LOCATION. Numeric PII (phone/card/SSN) is NOT
+// the model's job — the deterministic regex layer in @chatpanel/pii handles that,
+// same as before.
+//
+// Fail-open by design: if the model can't load (e.g. first run with no network and
+// no cached weights), the gateway logs one line and runs deterministic-only.
+
+import os from 'node:os';
+import { join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+
+const DEFAULT_MODEL = 'Xenova/bert-base-NER';
+
+// Download models from ChatPanel's own CDN (a branded, edge-cached proxy we
+// control) rather than directly from Hugging Face — so a clean install depends only
+// on chatpanel.net. Override with CHATPANEL_MODEL_BASE_URL (e.g. point at HF for
+// dev, or an air-gapped mirror). Must end with '/' (transformers appends the model
+// path template to it).
+const MODEL_HOST = (process.env.CHATPANEL_MODEL_BASE_URL || 'https://dl.chatpanel.net/models/').replace(/\/*$/, '/');
+
+let _state = 'off';        // 'off' | 'loading' | 'downloading' | 'ready' | 'error'
+let _model = null;         // active model id, e.g. 'Xenova/bert-base-NER'
+let _pipe = null;          // the loaded token-classification pipeline
+let _err = null;           // last error message (for /status)
+let _initPromise = null;   // single-flight init
+let _lib = null;           // memoized { env, pipeline } from transformers (imported once)
+let _progress = null;      // { model, file, pct } while a model is downloading, else null
+
+// Where model weights live ON DISK. A real, writable, persistent user dir — NOT
+// inside node_modules (wiped on reinstall, and absent entirely in a compiled
+// binary). The settings "download larger models" flow writes here too.
+export function modelRoot() {
+  return process.env.CHATPANEL_MODELS_DIR || join(os.homedir(), '.chatpanel', 'models');
+}
+
+// Is the model already on disk? (q8 = the quantized weights we load.) When present
+// we load fully offline — no network, a hard privacy guarantee.
+export function modelOnDisk(modelId = _model || DEFAULT_MODEL) {
+  const dir = join(modelRoot(), ...modelId.split('/'));
+  return existsSync(join(dir, 'onnx', 'model_quantized.onnx')) || existsSync(join(dir, 'onnx', 'model.onnx'));
+}
+
+export function state() { return _state; }
+export function isReady() { return _state === 'ready' && !!_pipe; }
+
+// Shape the /status `ner` block consumes. `url` is reported by the server as the
+// public in-process contract (http://host:port/ner); we expose the model + state.
+export function health() {
+  return {
+    configured: _state !== 'off',
+    ok: isReady(),
+    state: _state,
+    model: _model,
+    error: _err,
+  };
+}
+
+// PER/ORG/LOC/MISC come back as `entity_group`. We hand {value,type} straight to
+// @chatpanel/pii, whose normalizeEntities() maps PER->PERSON, ORG->ORG,
+// LOC->LOCATION and applies the user's category toggles — one source of truth.
+//
+// Subword healing: wordpiece tokenizers can occasionally split a name even with
+// aggregation on (e.g. "Acme" -> "A" + "##cme"). A leaked "##" fragment or a
+// 1-char head would NOT string-match the original text, leaving PII un-redacted.
+// So we stitch a `##` continuation back onto the previous same-type span. This is
+// belt-and-suspenders — most spans already arrive merged.
+export async function detect(text, { signal } = {}) {
+  if (!isReady()) return [];
+  if (signal?.aborted) return [];
+  const out = await _pipe(String(text || ''), { aggregation_strategy: 'simple' });
+  const ents = [];
+  for (const e of out || []) {
+    let word = String(e.word ?? '');
+    const type = e.entity_group ?? e.entity ?? 'ENTITY';
+    if (word.startsWith('##') && ents.length && ents[ents.length - 1].type === type) {
+      // Continuation of the previous token (no space): "A" + "##cme Corp".
+      ents[ents.length - 1].value += word.slice(2);
+      continue;
+    }
+    word = word.replace(/##/g, '').trim();
+    if (!word) continue;
+    ents.push({ value: word, type });
+  }
+  // Drop noise: a lone 1-char span that didn't get stitched is never useful PII.
+  return ents.filter((e) => e.value.length > 1);
+}
+
+// Lets @chatpanel/pii's existing `endpoint` detection backend call us with NO real
+// HTTP and NO second port: pii POSTs {text}->{entities} to a URL; we intercept by
+// being passed as `fetchImpl`, run the model in-process, and return a Response.
+// This reuses all of pii's caching / timeout / type-gating untouched.
+export async function fetchAdapter(_url, opts = {}) {
+  let text = '';
+  try { text = JSON.parse(opts.body || '{}').text || ''; } catch { /* empty */ }
+  const entities = await detect(text, { signal: opts.signal });
+  return new Response(JSON.stringify({ entities }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+// Live download progress for the model currently being fetched (or null). The
+// extension's model manager polls this. { model, file, pct }.
+export function progress() { return _progress; }
+
+// Import transformers ONCE and configure its env (model dir + WASM in a binary).
+async function ensureLib() {
+  if (_lib) return _lib;
+  const root = modelRoot();
+  try { mkdirSync(root, { recursive: true }); } catch { /* best effort */ }
+
+  // In a Bun --compile single-file binary there is no native onnxruntime-node (its
+  // dylib can't be embedded), so the binary entry embeds the onnxruntime-web WASM
+  // runtime and hands us its paths via this global. When present we force the WASM
+  // backend (transformers picks it when it doesn't see a Node env) BEFORE importing
+  // transformers. The npm/Node path leaves this unset and uses the faster native
+  // runtime.
+  const wasmPaths = globalThis.__CHATPANEL_WASM_PATHS__ || null;
+  if (wasmPaths) {
+    try { Object.defineProperty(process, 'release', { value: { ...process.release, name: 'bun' }, configurable: true }); } catch { /* ignore */ }
+  }
+
+  const { env, pipeline } = await import('@huggingface/transformers');
+  env.cacheDir = root;          // where remote downloads are cached
+  env.localModelPath = root;    // where local loads resolve — same dir, we control it
+  try { env.remoteHost = MODEL_HOST; } catch { /* optional */ }
+  try { env.backends.onnx.wasm.numThreads = 1; } catch { /* optional */ }
+  if (wasmPaths) {
+    // Single-thread + no proxy + preloaded wasm bytes — avoids the `blob:` ESM-scheme
+    // failure when ORT-web runs outside a browser.
+    try { env.backends.onnx.wasm.proxy = false; env.backends.onnx.wasm.wasmPaths = wasmPaths; } catch { /* optional */ }
+  }
+  _lib = { env, pipeline };
+  return _lib;
+}
+
+// (Re)load a specific model into _pipe. Downloads it first if missing (and allowed).
+// Reusable by init() and setModel(). Fail-open: on error, state='error', _pipe stays
+// whatever it was (so a failed SWITCH doesn't kill a working detector).
+async function loadModel(modelId, { log = () => {}, allowDownload = true } = {}) {
+  const prevPipe = _pipe;
+  const prevModel = _model;
+  let lib;
+  try {
+    lib = await ensureLib();
+  } catch (e) {
+    _state = 'error'; _err = `engine load failed: ${e.message}`;
+    log(`[ner] transformers.js not available (${e.message}) — deterministic-only`);
+    return false;
+  }
+
+  const haveLocal = modelOnDisk(modelId);
+  // Offline if cached (fast + private); only reach the network when missing.
+  lib.env.allowRemoteModels = haveLocal ? false : !!allowDownload;
+  if (!haveLocal && !allowDownload) {
+    _state = 'error'; _err = 'model not on disk and downloads disabled';
+    log(`[ner] model ${modelId} not installed and downloads disabled — deterministic-only`);
+    return false;
+  }
+
+  _state = haveLocal ? 'loading' : 'downloading';
+  if (!haveLocal) { _progress = { model: modelId, file: null, pct: 0 }; log(`[ner] downloading model ${modelId} (one-time)…`); }
+
+  try {
+    const pipe = await lib.pipeline('token-classification', modelId, {
+      dtype: 'q8',
+      progress_callback: (p) => {
+        if (!p) return;
+        const pct = typeof p.progress === 'number' ? Math.round(p.progress) : (_progress?.pct ?? 0);
+        if (p.status === 'progress' || p.status === 'download' || p.status === 'initiate') {
+          _progress = { model: modelId, file: p.file || _progress?.file || null, pct };
+        } else if (p.status === 'done' && p.file) {
+          log(`[ner] fetched ${p.file}`);
+        }
+      },
+    });
+    // Swap in the new pipeline, dispose the old one (free its WASM/native session).
+    _pipe = pipe; _model = modelId; _state = 'ready'; _err = null; _progress = null;
+    if (prevPipe && prevPipe !== pipe) { try { await prevPipe.dispose?.(); } catch { /* ignore */ } }
+    log(`[ner] ready — model ${modelId} (in-process, no Python) — entity detection active`);
+    return true;
+  } catch (e) {
+    _err = e.message; _progress = null;
+    // Keep any previously-working detector rather than going dark on a bad switch.
+    if (prevPipe) { _pipe = prevPipe; _model = prevModel; _state = 'ready'; }
+    else { _state = 'error'; }
+    log(`[ner] model load failed (${e.message})${prevPipe ? ' — keeping previous model' : ' — deterministic-only'}`);
+    return false;
+  }
+}
+
+// Load the default/configured model once at startup. Returns a promise that
+// resolves when ready (or after a fail-open error). `cfg` = { model?, allowDownload?, onLog? }.
+export function init(cfg = {}) {
+  if (_initPromise) return _initPromise;
+  const log = typeof cfg.onLog === 'function' ? cfg.onLog : () => {};
+  _model = cfg.model || DEFAULT_MODEL;
+  _state = 'loading';
+  _initPromise = loadModel(_model, { log, allowDownload: cfg.allowDownload !== false });
+  return _initPromise;
+}
+
+// Switch to a different model (download it first if needed). Used by the model
+// manager. Returns true on success. A failed switch keeps the current detector.
+export async function setModel(modelId, opts = {}) {
+  const log = typeof opts.onLog === 'function' ? opts.onLog : () => {};
+  const allowDownload = opts.allowDownload !== false;
+  if (!modelId) return false;
+  if (modelId === _model && isReady()) return true;
+  return loadModel(modelId, { log, allowDownload });
+}
+
+// Test hook: reset module state (used by unit tests).
+export function _reset() {
+  _state = 'off'; _model = null; _pipe = null; _err = null; _initPromise = null; _lib = null; _progress = null;
+}

package/src/ner.js

@@ -1,168 +1,43 @@
-// Managed local NER server. When cfg.ner.autostart is on, launching the gateway
-// also spins up the bundled spaCy detector (./ner) and wires redaction.detection
-// at it — so name/org redaction works with a single command, no second terminal.
+// Managed in-process NER. When cfg.ner.autostart is on, launching the gateway
+// loads the bundled ONNX entity detector (./ner-engine.js) and flips redaction to
+// full tier once it's ready — name/org redaction with a single command, no second
+// process, no second port, no Python.
 //
-// Fail-open by design: if Python/spaCy isn't set up, we log a one-line hint and
-// the gateway keeps running with deterministic-only redaction (the detector layer
-// is already cached + fail-open per request).
+// Fail-open by design: if the model can't load (e.g. first run, no network, no
+// cached weights), we log a one-line hint and the gateway keeps running with
+// deterministic-only redaction. redact.js consults the engine directly, so we do
+// NOT mutate cfg.redaction.detection here (that field is reserved for a user's own
+// external detector, which takes precedence — see below).
 
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync } from 'node:fs';
-import os from 'node:os';
-import { NER_ASSETS } from './ner-assets.js';
+import * as engine from './ner-engine.js';
 
-// Where the NER server lives ON DISK. We always run from a real, writable user dir
-// (~/.chatpanel/ner) rather than the package's ner/ — because a STANDALONE BINARY
-// has no ner/ on the filesystem at all (it's inside the SEA snapshot), and a global
-// npm dir may be read-only. The venv + installed deps persist here across restarts.
-function materializeNerDir() {
-  const dir = join(os.homedir(), '.chatpanel', 'ner');
-  try {
-    mkdirSync(dir, { recursive: true });
-    for (const [name, b64] of Object.entries(NER_ASSETS)) {
-      const target = join(dir, name);
-      const want = Buffer.from(b64, 'base64');
-      // Refresh the scripts if changed (pick up updates), but never touch .venv.
-      const have = existsSync(target) ? readFileSync(target) : null;
-      if (!have || !have.equals(want)) writeFileSync(target, want);
-      if (name.endsWith('.sh')) { try { chmodSync(target, 0o755); } catch { /* best effort */ } }
-    }
-    return dir;
-  } catch (e) {
-    console.log(`[ner] could not materialize NER dir at ${dir} (${e.message})`);
-    return null;
-  }
-}
-
-// A login service (LaunchAgent / systemd) inherits a MINIMAL PATH — not your
-// shell's — so `bash` and a pyenv/homebrew `python3` aren't found. Resolve bash
-// absolutely and enrich PATH with the usual locations so run.sh + python3 work.
-function resolveBash() {
-  for (const p of ['/bin/bash', '/usr/bin/bash', '/usr/local/bin/bash', '/opt/homebrew/bin/bash']) {
-    if (existsSync(p)) return p;
-  }
-  return 'bash';
-}
-
-function enrichedPath(home = os.homedir(), base = process.env.PATH || '') {
-  const extra = [
-    '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin',
-    join(home, '.pyenv', 'shims'), join(home, '.pyenv', 'bin'),
-    join(home, '.local', 'bin'),
-  ];
-  return [...new Set([...base.split(':').filter(Boolean), ...extra])].join(':');
-}
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// Probe the ACTUAL /ner contract (POST {text} -> {entities}), not /health: many
-// NER servers (incl. a user's own) expose only /ner. If anything answers here, we
-// can use it as the detector.
-async function nerReachable(port, signal) {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/ner`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ text: 'ping' }),
-      signal,
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
-// Launch + supervise the NER server (or adopt one already on the port). Returns
-// { stop() } or null if not started. Mutates cfg.redaction once NER answers.
 export function startNer(cfg) {
   const n = cfg.ner;
   if (!n || !n.autostart) return null;
 
-  const port = n.port || 9009;
-  const bundledUrl = `http://127.0.0.1:${port}/ner`;
-
-  // Respect a USER-configured detector pointing elsewhere (a custom NER, a local
-  // LLM) — don't relaunch — but still apply the full-tier bump. If detection is
-  // off OR points at our own bundled NER, fall through and (re)launch/adopt it,
-  // so a persisted "detection→bundled" config doesn't leave NER actually down.
+  // Respect a USER-configured external detector (a custom NER endpoint or a local
+  // LLM): don't load the bundled engine — just apply the full-tier bump so their
+  // detector is actually used.
   const det = cfg.redaction?.detection;
-  const userDetector = det && det.backend && det.backend !== 'off' && det.url !== bundledUrl;
-  if (userDetector) {
+  if (det && det.backend && det.backend !== 'off') {
     if (n.enableFullTier && cfg.redaction.tier !== 'full') cfg.redaction.tier = 'full';
     console.log(`[ner] using configured detector (${det.backend} ${det.url || ''}) — full tier ${cfg.redaction.tier === 'full' ? 'on' : 'off'}`);
     return null;
   }
-  let stopped = false;
-  let child = null;
-  const ac = new AbortController();
-
-  const wire = (how) => {
-    cfg.redaction.detection = { backend: 'endpoint', url: `http://127.0.0.1:${port}/ner`, timeoutMs: 1500, maxChars: 8000 };
-    if (n.enableFullTier && cfg.redaction.tier !== 'full') cfg.redaction.tier = 'full';
-    console.log(`[ner] ${how} on http://127.0.0.1:${port}/ner — entity detection active (tier: ${cfg.redaction.tier})`);
-  };
 
-  (async () => {
-    // 1) Adopt an existing NER already serving on the port (e.g. the user's own).
-    if (await nerReachable(port, ac.signal)) { wire('using existing NER'); return; }
-
-    // 2) Otherwise launch the bundled spaCy server — materializing run.sh +
-    //    server.py + requirements.txt to a real on-disk dir first (the binary has
-    //    no ner/ on the FS). run.sh then creates the venv, installs deps, and runs.
-    const nerDir = materializeNerDir();
-    if (!nerDir) { console.log('[ner] no writable NER dir — deterministic redaction only'); return; }
-    try {
-      child = spawn(resolveBash(), ['run.sh'], {
-        cwd: nerDir,
-        env: {
-          ...process.env,
-          PORT: String(port),
-          PATH: enrichedPath(),
-          // Force official PyPI: a machine pinned to a private/corp index (in
-          // pip.conf) can't reach it off-VPN, which breaks the one-time install.
-          PIP_INDEX_URL: process.env.CHATPANEL_PIP_INDEX_URL || 'https://pypi.org/simple',
-          PIP_EXTRA_INDEX_URL: '',
-          PIP_DISABLE_PIP_VERSION_CHECK: '1',
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-    } catch (e) {
-      console.log(`[ner] could not launch bundled NER (${e.message}) — deterministic redaction only`);
-      return;
-    }
-    let firstRun = true;
-    child.stdout?.on('data', (b) => {
-      if (firstRun && /installing dependencies/i.test(b.toString())) {
-        firstRun = false;
-        console.log('[ner] first run: creating venv + installing spaCy (one-time, may take a minute)…');
-      }
-    });
-    child.stderr?.on('data', () => { /* uvicorn logs to stderr; swallow */ });
-    child.on('error', (e) => console.log(`[ner] failed to start (${e.message}). Is python3 installed? Falling back to deterministic redaction.`));
-    child.on('exit', (code) => {
-      if (code && code !== 0 && !stopped) {
-        // The bundled one couldn't bind (often the port is taken by another NER).
-        // If SOMETHING answers /ner there, adopt it instead of giving up.
-        nerReachable(port, ac.signal).then((ok) => { if (ok && !stopped) wire('adopted NER'); else if (!stopped) console.log(`[ner] server exited (code ${code}); deterministic-only.`); });
-      }
-    });
-
-    // 3) Poll for readiness; wire detection when up.
-    const deadline = Date.now() + 300_000; // generous: first run installs deps
-    while (Date.now() < deadline && !stopped) {
-      if (await nerReachable(port, ac.signal)) { wire('ready'); return; }
-      await sleep(1000);
+  let stopped = false;
+  engine.init({
+    model: n.model,
+    allowDownload: n.allowDownload !== false,
+    onLog: (m) => { if (!stopped) console.log(m); },
+  }).then(() => {
+    if (stopped) return;
+    if (engine.isReady() && n.enableFullTier && cfg.redaction.tier !== 'full') {
+      cfg.redaction.tier = 'full';
+      console.log(`[ner] full tier on — name/org redaction active`);
     }
-    if (!stopped) console.log(`[ner] not ready after 300s — continuing deterministic-only (run ${join(os.homedir(), '.chatpanel', 'ner', 'run.sh')} manually to debug).`);
-  })();
+  }).catch((e) => { if (!stopped) console.log(`[ner] init error (${e.message}) — deterministic-only`); });
 
-  const stop = () => {
-    if (stopped) return;
-    stopped = true;
-    ac.abort();
-    try { child?.kill('SIGTERM'); } catch { /* ignore */ }
-  };
-  return { stop };
+  // Nothing to kill (no child process); just stop logging after shutdown.
+  return { stop() { stopped = true; } };
 }

package/src/redact.js

@@ -9,6 +9,7 @@
 // extension's pii-pipeline.)
 
 import { createVault, redactText, detectEntities, effectiveTier, gatedDictionary } from '@chatpanel/pii';
+import * as engine from './ner-engine.js';
 
 // tier: 'basic' | 'full'. For 'full' we run the local detector over the combined
 // text to harvest names/orgs, then redact every segment against that entity set.
@@ -25,17 +26,27 @@ export async function redactSegments(segments, redactionCfg, { signal, isPro = t
   const tier = effectiveTier({ tier: redactionCfg.tier }, isPro);
   const dictionary = gatedDictionary(redactionCfg, isPro);
 
+  // Detection source: a USER-configured external detector takes precedence; else
+  // the bundled in-process engine (no second port — we hand pii-detect a fetchImpl
+  // that runs the model in-process instead of doing real HTTP). Either way we reuse
+  // @chatpanel/pii's caching / timeout / type-gating — one source of truth.
+  const det = redactionCfg.detection;
+  const useExternal = !!(det && det.backend && det.backend !== 'off');
+  const useEngine = !useExternal && engine.isReady();
+
   let entities = [];
-  if (tier === 'full' && redactionCfg.detection?.backend && redactionCfg.detection.backend !== 'off') {
-    // One detection pass over the joined text — the detector is cached + fail-open,
-    // so a slow/broken NER service never blocks the request (deterministic layer
-    // still runs). Give it a generous CEILING (matching the extension): a fast NER
-    // returns in well under a second, but a slow/cold detector must be allowed to
-    // finish — if it times out, the turn falls back to dictionary/deterministic-only
-    // redaction (permanent pseudonyms the reply-restorer can't undo).
-    const detection = { ...redactionCfg.detection, timeoutMs: Math.max(Number(redactionCfg.detection.timeoutMs) || 0, 30000) };
+  if (tier === 'full' && (useExternal || useEngine)) {
+    // One detection pass over the joined text — cached + fail-open, so a slow/broken
+    // detector never blocks the request (the deterministic layer still runs). Give it
+    // a generous CEILING (matching the extension): a fast detector returns in well
+    // under a second, but a cold one must be allowed to finish; on timeout the turn
+    // falls back to dictionary/deterministic-only redaction.
+    const detection = useEngine
+      ? { backend: 'endpoint', url: 'inproc:ner', timeoutMs: 30000, maxChars: 8000, types: det?.types }
+      : { ...det, timeoutMs: Math.max(Number(det.timeoutMs) || 0, 30000) };
+    const fetchImpl = useEngine ? engine.fetchAdapter : undefined;
     try {
-      entities = await detectEntities(texts.join('\n\n'), { detection }, { signal });
+      entities = await detectEntities(texts.join('\n\n'), { detection }, { signal, fetchImpl });
     } catch {
       entities = [];
     }

package/src/server.js

@@ -26,6 +26,8 @@ import { streamBridgeChat, readBridgeToken, openBridgeChat } from './bridge.js';
 import { createRelaySession, getRelaySession, endRelaySession, pumpBridgeStream, deliverToolResult, toolsToSpecs, parseToolCallId } from './toolrelay.js';
 import { shaperFor } from './shape.js';
 import { startNer } from './ner.js';
+import * as nerEngine from './ner-engine.js';
+import { MODEL_CATALOG, isKnownModel } from './models.js';
 import { resolvePro, meter, usage } from './freegate.js';
 import { publicConfig, applyConfigPatch, persistConfig, configPath } from './configstore.js';
 import { resolveDestination, aggregateModelsAsync } from './router.js';
@@ -33,7 +35,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.5.5';
+export const VERSION = '0.6.0';
 
 const KNOWN_AGENTS = new Set(['codex', 'claude', 'opencode', 'pi', 'kiro', 'antigravity']);
 
@@ -41,7 +43,7 @@ const KNOWN_AGENTS = new Set(['codex', 'claude', 'opencode', 'pi', 'kiro', 'anti
 // the extension's AUTO mode via the SAME shared ranker. We narrow only tools whose
 // name looks like an MCP tool (server-prefixed) so a client's CORE tools (bash,
 // read, edit…) are never dropped — that would break agent clients like OpenCode.
-const DEFAULT_GATEWAY_TOOL_CAP = 8;
+const DEFAULT_GATEWAY_TOOL_CAP = 16;
 const MCP_NAME_RE = /^mcp[_-]/i;
 const toolName = (t) => (t && t.function && t.function.name) || (t && t.name) || '';
 const toolDesc = (t) => (t && t.function && t.function.description) || (t && t.description) || '';
@@ -162,16 +164,30 @@ function sendJson(res, status, obj) {
   res.end(JSON.stringify(obj));
 }
 
-// The detector URL (…:9009/ner) and its sibling /health. Returns null when no
-// detector is wired (deterministic-only).
+// A USER-configured external detector's URL and its sibling /health. Returns null
+// when no external detector is wired (the bundled in-process engine is handled
+// separately in probeNerHealth / the /ner route).
 function nerBaseUrl(cfg) {
   const url = cfg.redaction?.detection?.url;
   if (!url || cfg.redaction?.detection?.backend === 'off') return null;
   return url;
 }
 
-// Live health probe of the bundled/configured NER (GET /health → { ok, model }).
+// Health of the detector for /status. The bundled IN-PROCESS engine takes
+// precedence; its public contract URL is the gateway's own /ner (no second port).
+// A user-configured external detector is probed over HTTP as before.
 async function probeNerHealth(cfg) {
+  if (nerEngine.state() !== 'off') {
+    const h = nerEngine.health();
+    return {
+      configured: h.configured,
+      ok: h.ok,
+      state: h.state,
+      model: h.model,
+      error: h.error || null,
+      url: h.configured ? `http://${cfg.host}:${cfg.port}/ner` : null,
+    };
+  }
   const url = nerBaseUrl(cfg);
   if (!url) return { configured: false, ok: false, url: null, model: null };
   try {
@@ -381,16 +397,30 @@ export function createGateway(cfg = loadConfig()) {
         uptimeSeconds: Math.floor((Date.now() - STARTED_AT) / 1000),
       });
     }
-    // Proxy the detector so it's checkable on the gateway's own port (the NER runs
-    // on its own port, e.g. 9009 — hitting :4320/ner used to 404). GET → health.
+    // The detector, on the gateway's own port (no second port). GET → health;
+    // POST {text} → {entities}. The bundled engine runs IN-PROCESS; a user's own
+    // external detector (if configured) is proxied for back-compat.
     if (pathname === '/ner') {
-      const url = nerBaseUrl(cfg);
-      if (!url) return sendJson(res, 503, { error: { message: 'NER not configured — deterministic-only redaction', type: 'ner_off' } });
       if (req.method === 'GET') {
         const health = await probeNerHealth(cfg);
         return sendJson(res, health.ok ? 200 : 503, health);
       }
       if (req.method === 'POST') {
+        // In-process engine path.
+        if (nerEngine.state() !== 'off') {
+          try {
+            const body = await readBody(req, cfg.maxBodyBytes);
+            let text = '';
+            try { text = JSON.parse(body.toString('utf8'))?.text || ''; } catch { /* empty */ }
+            const entities = await nerEngine.detect(text);
+            return sendJson(res, 200, { entities });
+          } catch (e) {
+            return sendJson(res, 500, { error: { message: `NER error: ${e.message}`, type: 'ner_error' } });
+          }
+        }
+        // External detector proxy (user-configured endpoint).
+        const url = nerBaseUrl(cfg);
+        if (!url) return sendJson(res, 503, { error: { message: 'NER not configured — deterministic-only redaction', type: 'ner_off' } });
         try {
           const body = await readBody(req, cfg.maxBodyBytes);
           const r = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body, signal: AbortSignal.timeout(8000) });
@@ -402,6 +432,34 @@ export function createGateway(cfg = loadConfig()) {
         }
       }
     }
+    // Model manager (the extension's Gateway settings drive these). GET lists the
+    // catalog with install state + live download progress; POST switches the active
+    // model (downloading it first if needed) and persists the choice.
+    if (pathname === '/ner/models') {
+      if (req.method === 'GET') {
+        const available = MODEL_CATALOG.map((m) => ({ ...m, installed: nerEngine.modelOnDisk(m.id) }));
+        return sendJson(res, 200, {
+          active: nerEngine.health().model || cfg.ner?.model || null,
+          state: nerEngine.state(),
+          progress: nerEngine.progress(),
+          available,
+        });
+      }
+      if (req.method === 'POST') {
+        let body = null;
+        try { body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')); } catch { body = null; }
+        const id = body && typeof body.id === 'string' ? body.id : null;
+        if (!id || !isKnownModel(id)) return sendJson(res, 400, { error: { message: 'unknown model id', type: 'bad_model' } });
+        // Persist first so a restart keeps the choice, then (re)load. Don't block the
+        // response on a possibly-long download — the client polls GET for progress.
+        if (cfg.ner) cfg.ner.model = id; else cfg.ner = { autostart: true, model: id, allowDownload: true, enableFullTier: true };
+        try { persistConfig(cfg, configPath()); } catch { /* best effort */ }
+        nerEngine.setModel(id, { onLog: (m) => console.log(m) }).then((ok) => {
+          if (ok && cfg.ner?.enableFullTier && cfg.redaction.tier !== 'full') cfg.redaction.tier = 'full';
+        });
+        return sendJson(res, 202, { accepted: true, active: id, state: nerEngine.state(), progress: nerEngine.progress() });
+      }
+    }
     if (pathname === '/logs' && req.method === 'GET') {
       return sendJson(res, 200, { entries: [...recentRequests].reverse() }); // newest first; counts only
     }

package/ner/README.md

@@ -1,84 +0,0 @@
-# ChatPanel — local NER helper (spaCy)
-
-A ~30-line local service that lets ChatPanel **auto-redact names, organizations,
-and locations** before anything is sent to a chat model. Detection runs entirely
-on your machine; the model only ever sees placeholders like `[[PERSON_1]]`.
-
-ChatPanel's redaction contract is simple — any local HTTP service works:
-
-```
-POST /ner   { "text": "..." }
-→           { "entities": [ { "value": "Alex", "type": "PERSON" }, ... ] }
-```
-
-(spaCy's `{ "ents": [{ "text", "label" }] }` shape is also accepted, as is a
-local OpenAI-compatible LLM — see "Other detectors" below.)
-
-## Quick start
-
-Most machines block installing Python packages globally, so use a virtual env:
-
-```bash
-cd helpers/ner-server
-
-python3 -m venv .venv
-source .venv/bin/activate            # Windows: .venv\Scripts\activate
-pip install -r requirements.txt
-python -m spacy download en_core_web_sm
-
-uvicorn server:app --port 9009       # the file is server.py → import path "server:app"
-```
-
-…or just run the bundled script (does all of the above):
-
-```bash
-./run.sh                             # PORT=9100 ./run.sh to change the port
-```
-
-Check it's up: `curl http://127.0.0.1:9009/health`
-
-## Point ChatPanel at it
-
-**Settings → Privacy** (or the 🛡 button in the chat composer):
-
-| Field | Value |
-|------|-------|
-| Redaction | **On — + AI detection** |
-| Detector | **Local NER service (spaCy / Presidio)** |
-| Detector URL | `http://127.0.0.1:9009/ner` |
-| Redact types | People / Organizations / Locations / Numbers (your choice) |
-
-Now `my name is Alex from Denver` is sent to the model as
-`my name is [[PERSON_1]] from [[LOCATION_1]]`, and the reply is restored to the
-real values in your view.
-
-> Turning **Locations** off keeps city names readable (useful for "how far is X
-> from Y" questions) while still redacting people.
-
-## Accuracy vs. speed
-
-`en_core_web_sm` is small and fast (good default). For fewer misses:
-
-```bash
-python -m spacy download en_core_web_md     # or en_core_web_trf (best, heavier)
-```
-
-then change `MODEL` in `server.py`. Small models can over-tag short acronyms as
-`ORG`; ChatPanel drops noisy short numerics/dates automatically and lets you turn
-off whole categories.
-
-## Other detectors
-
-ChatPanel doesn't care what's behind the URL, as long as it returns the entity
-shape above. Drop-in alternatives:
-
-- **Microsoft Presidio** — `presidio-analyzer` behind a small FastAPI wrapper
-  (returns `{ "results": [...] }`, also accepted).
-- **A local LLM** — set the detector to **Local LLM (OpenAI-compatible)** and
-  point it at Ollama / LM Studio / llama.cpp (e.g. `http://127.0.0.1:11434`);
-  ChatPanel prompts it for strict JSON entities. Slower than spaCy, no extra
-  service to run if you already have a local model. See `../local-model.md`.
-
-Everything is local and latency-guarded (cached + timed out + fail-open): if the
-detector is slow or down, ChatPanel falls back to deterministic redaction so chat
-never blocks.

package/ner/requirements.txt

@@ -1,3 +0,0 @@
-fastapi
-uvicorn[standard]
-spacy

package/ner/run.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# One-shot: create the venv (if needed), install deps + the spaCy model, and serve.
-# Usage:  ./run.sh        (defaults to port 9009)
-#         PORT=9100 ./run.sh
-set -euo pipefail
-cd "$(dirname "$0")"
-
-if [ ! -d .venv ]; then
-  echo "→ creating virtual env (.venv)…"
-  python3 -m venv .venv
-fi
-# shellcheck disable=SC1091
-source .venv/bin/activate
-
-echo "→ installing dependencies…"
-pip install -q --upgrade pip
-pip install -q -r requirements.txt
-python -c "import en_core_web_sm" >/dev/null 2>&1 || python -m spacy download en_core_web_sm
-
-echo "→ serving on http://127.0.0.1:${PORT:-9009}/ner  (Ctrl-C to stop)"
-exec uvicorn server:app --port "${PORT:-9009}"

package/ner/server.py

@@ -1,95 +0,0 @@
-"""
-ChatPanel local NER helper — a tiny on-device entity detector for PII redaction.
-
-ChatPanel's Privacy → "AI detection" can point at any LOCAL service that accepts
-    POST {"text": "..."}
-and returns
-    {"entities": [{"value": "...", "type": "PERSON|ORG|GPE|EMAIL|PHONE|..."}]}
-
-This wraps spaCy (people / organizations / locations) AND adds a regex pass for
-the structured identifiers spaCy doesn't emit (emails, phone numbers, SSNs, cards,
-IPs), so the detector is comprehensive on its own. Only the redacted placeholders
-(e.g. [[PERSON_1]]) ever reach the chat model — the raw text never leaves your box.
-
---------------------------------------------------------------------------------
-Setup  (most machines block global pip installs, so use a virtual env)
-
-    python3 -m venv .venv
-    source .venv/bin/activate          # Windows: .venv\\Scripts\\activate
-    pip install -r requirements.txt
-    python -m spacy download en_core_web_sm
-
-Run  (the file is server.py, so the uvicorn import path is "server:app")
-
-    uvicorn server:app --port 9009
-
-Then in ChatPanel → Settings → Privacy:
-    Redaction : On — + AI detection
-    Detector  : Local NER service (spaCy / Presidio)
-    URL       : http://127.0.0.1:9009/ner
-
-Tip: en_core_web_sm is small + fast. For better accuracy use en_core_web_md or
-en_core_web_trf (download the same way, then change the load below).
---------------------------------------------------------------------------------
-"""
-from fastapi import FastAPI
-
-import re
-import spacy
-
-MODEL = "en_core_web_sm"
-nlp = spacy.load(MODEL)
-
-app = FastAPI(title="ChatPanel NER helper")
-
-# spaCy's NER emits names / orgs / locations but NOT structured identifiers, so add
-# a regex pass for those. (ChatPanel also catches these on-device, but emitting them
-# here keeps the detector self-contained — what you test is what you get.) Order
-# matters: more specific patterns run first so a card / SSN isn't re-matched as a
-# phone number.
-_PATTERNS = [
-    ("EMAIL", re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}")),
-    ("SSN", re.compile(r"\b\d{3}-\d{2}-\d{4}\b")),
-    ("CREDIT_CARD", re.compile(r"\b(?:\d[ -]?){13,19}\b")),
-    ("IP", re.compile(r"\b(?:\d{1,3}\.){3}\d{1,3}\b")),
-    ("PHONE", re.compile(r"(?<!\d)(?:\+?\d{1,2}[ .\-]?)?\(?\d{3}\)?[ .\-]?\d{3}[ .\-]?\d{4}(?!\d)")),
-]
-
-
-def _regex_entities(text):
-    out, taken = [], []
-    for label, rx in _PATTERNS:
-        for m in rx.finditer(text):
-            start, end = m.start(), m.end()
-            if any(start < te and ts < end for ts, te in taken):
-                continue  # span already claimed by a more specific pattern
-            taken.append((start, end))
-            out.append({"value": m.group(0).strip(), "type": label})
-    return out
-
-
-@app.get("/health")
-def health():
-    return {"ok": True, "model": MODEL}
-
-
-@app.post("/ner")
-def ner(payload: dict):
-    """Return spaCy entities + regex identifiers in ChatPanel's expected shape.
-
-    ChatPanel maps common labels itself (PER→PERSON, GPE→LOCATION, …) and keeps
-    only the categories you enable in the Privacy tab, so it's fine to return all
-    of them here.
-    """
-    text = (payload or {}).get("text", "") or ""
-    doc = nlp(text)
-    ents = [{"value": ent.text, "type": ent.label_} for ent in doc.ents]
-    ents.extend(_regex_entities(text))
-    # De-dup identical value+type (spaCy and a regex can both surface the same span).
-    seen, out = set(), []
-    for e in ents:
-        key = (e["type"], e["value"].lower())
-        if e["value"] and key not in seen:
-            seen.add(key)
-            out.append(e)
-    return {"entities": out}

package/src/ner-assets.js

@@ -1,8 +0,0 @@
-// GENERATED by scripts/gen-ner-assets.mjs — do NOT edit. Edit ner/* and re-run.
-// Base64 of the bundled spaCy NER server, embedded so a standalone binary can
-// write a runnable ner/ directory to disk (the binary has no ner/ on the FS).
-export const NER_ASSETS = {
-  "run.sh": "IyEvdXNyL2Jpbi9lbnYgYmFzaAojIE9uZS1zaG90OiBjcmVhdGUgdGhlIHZlbnYgKGlmIG5lZWRlZCksIGluc3RhbGwgZGVwcyArIHRoZSBzcGFDeSBtb2RlbCwgYW5kIHNlcnZlLgojIFVzYWdlOiAgLi9ydW4uc2ggICAgICAgIChkZWZhdWx0cyB0byBwb3J0IDkwMDkpCiMgICAgICAgICBQT1JUPTkxMDAgLi9ydW4uc2gKc2V0IC1ldW8gcGlwZWZhaWwKY2QgIiQoZGlybmFtZSAiJDAiKSIKCmlmIFsgISAtZCAudmVudiBdOyB0aGVuCiAgZWNobyAi4oaSIGNyZWF0aW5nIHZpcnR1YWwgZW52ICgudmVudinigKYiCiAgcHl0aG9uMyAtbSB2ZW52IC52ZW52CmZpCiMgc2hlbGxjaGVjayBkaXNhYmxlPVNDMTA5MQpzb3VyY2UgLnZlbnYvYmluL2FjdGl2YXRlCgplY2hvICLihpIgaW5zdGFsbGluZyBkZXBlbmRlbmNpZXPigKYiCnBpcCBpbnN0YWxsIC1xIC0tdXBncmFkZSBwaXAKcGlwIGluc3RhbGwgLXEgLXIgcmVxdWlyZW1lbnRzLnR4dApweXRob24gLWMgImltcG9ydCBlbl9jb3JlX3dlYl9zbSIgPi9kZXYvbnVsbCAyPiYxIHx8IHB5dGhvbiAtbSBzcGFjeSBkb3dubG9hZCBlbl9jb3JlX3dlYl9zbQoKZWNobyAi4oaSIHNlcnZpbmcgb24gaHR0cDovLzEyNy4wLjAuMToke1BPUlQ6LTkwMDl9L25lciAgKEN0cmwtQyB0byBzdG9wKSIKZXhlYyB1dmljb3JuIHNlcnZlcjphcHAgLS1wb3J0ICIke1BPUlQ6LTkwMDl9Igo=",
-  "server.py": "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",
-  "requirements.txt": "ZmFzdGFwaQp1dmljb3JuW3N0YW5kYXJkXQpzcGFjeQo=",
-};