From c2aec749b462d6f2c3586188e66e26e3c4c95951 Mon Sep 17 00:00:00 2001 From: Inferencebot Date: Fri, 6 Nov 2026 04:05:01 +0000 Subject: [PATCH 1/6] overlay: rebase on appstore package 1.4.8 (candidate for 2026-11-08 window) - Dockerfile FROM: appstore 1.4.5 image (202610230221180000) -> 1.4.8 (202611030321030000). Same LibreChat upstream 0.8.8 in both - the package delta is tooling only: uv 0.13.5->0.13.7 and Node.js 22.23.4 (security fix, 1.4.7), base image 6.0.1 (eMudhra cert fix, 1.4.4 - already in 1.4.5). - All overlay anchors verified against the real 1.4.8 image dist (title tag, manifest link crossorigin, viewport meta, theme-color #171717, webmanifest name/colors, 'MCP Servers' + 'Every AI for Everyone.' strings, index.*.js, sw.js): unchanged, no porting needed. - release.sh BASE_IMAGE default follows the pin. --- CloudronManifest.json | 4 ++-- Dockerfile | 2 +- release.sh | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CloudronManifest.json b/CloudronManifest.json index bd94d84..787d242 100644 --- a/CloudronManifest.json +++ b/CloudronManifest.json @@ -1,6 +1,6 @@ { "id": "ai.librechat.cloudronapp", - "version": "1.4.5", + "version": "1.4.8", "title": "LibreChat", "upstreamVersion": "0.8.8", "author": "Danny Avila", @@ -56,4 +56,4 @@ ], "icon": "file://logo.png", "dockerImage": "registry.inference.coop/co-op/librechat-custom:20261031-2a98892" -} +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index 17ea43d..e0db542 100644 --- a/Dockerfile +++ b/Dockerfile @@ -20,7 +20,7 @@ # the manifest's scheduler task). All other behavior lives on the # persistent volume (/app/data/librechat.yaml, /app/data/env, # /app/data/mcp/) and survives image updates unchanged. -FROM cloudron/ai.librechat.cloudronapp:202610230221180000 +FROM cloudron/ai.librechat.cloudronapp:202611030321030000 # Login-page + header logo (the client bundle references assets/logo.svg) COPY assets/logo.svg /app/code/librechat/client/dist/assets/logo.svg diff --git a/release.sh b/release.sh index 186f6c6..4e3e622 100755 --- a/release.sh +++ b/release.sh @@ -28,7 +28,7 @@ set -euo pipefail APP=${APP:-4023ccbf-d57a-4500-97df-14de9cf3516e} REGISTRY_REPO=${REGISTRY_REPO:-registry.inference.coop/co-op/librechat-custom} SERVER=${SERVER:-my.inference.coop} -BASE_IMAGE=${BASE_IMAGE:-cloudron/ai.librechat.cloudronapp:202610150224320000} +BASE_IMAGE=${BASE_IMAGE:-cloudron/ai.librechat.cloudronapp:202611030321030000} MANIFEST=CloudronManifest.json die() { printf 'release.sh: %s\n' "$*" >&2; exit 1; } From 0c8cd05828bb4e47ff4c5bbd277def11ff6b22d3 Mon Sep 17 00:00:00 2001 From: Inferencebot Date: Sat, 7 Nov 2026 20:29:36 +0000 Subject: [PATCH 2/6] =?UTF-8?q?chat:=20mirror=20live=20librechat.yaml=20?= =?UTF-8?q?=E2=80=94=20STT/TTS=20endpoints,=20voxtral=20models,=20seeded?= =?UTF-8?q?=20speechTab,=20STT=20language=20default=20'en'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Syncs the repo to the deployed /app/data/librechat.yaml (md5 a856831404d5b522cd2e47a8e63466ad, verified in-container 2026-11-07): full /v1/audio/* endpoint URLs, tinfoil/voxtral-small-24b (STT) + tinfoil/voxtral-tts (TTS) with the 20 provider voices, seeded speechTab client defaults (external engines), and languageSTT 'en' pinned as the transcription-language default (members' own saved settings always win) after a first-press Spanish misdetect. This run's TTS latency fix lives in the gateway (code/litellm 5d38403), not here. --- librechat.yaml | 43 ++++++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/librechat.yaml b/librechat.yaml index f0c50ef..2f329a9 100644 --- a/librechat.yaml +++ b/librechat.yaml @@ -133,27 +133,48 @@ interface: rgb-border-light: '74 82 64' -# Speech (STT/TTS) via the co-op gateway. Uses a dedicated LiteLLM virtual key -# (alias: librechat-speech, $5/30d budget, restricted to the audio models) so -# speech never runs on the gateway master key. The gateway is a public +# Speech (STT/TTS) via the co-op gateway. LibreChat POSTs to `url` VERBATIM +# (no path is appended), so the FULL endpoint paths are required here. +# Uses a dedicated LiteLLM virtual key (alias: librechat-speech, $5/30d +# budget, restricted to the audio models) injected as STT_API_KEY/TTS_API_KEY +# app env — speech never runs on the master key. The gateway is a public # endpoint, so no SSRF allowedAddresses exemption is needed. +# STT: tinfoil/voxtral-small-24b — token-priced (~$0.00008/typical dictation +# request on the gateway) vs the flat $0.01/request of +# tinfoil/whisper-large-v3-turbo; same TEE provider, equal quality on short +# clips (verified round-trip 2026-11-07). Whisper stays allowed on the key as +# a one-line fallback swap. TTS: tinfoil/voxtral-tts, $0.002/request at cost; +# voices are the provider's supported speakers (an unknown name 400s). speech: tts: openai: - url: "https://gateway.inference.coop/v1" - apiKey: "${TTS_API_KEY}" + url: "https://gateway.inference.coop/v1/audio/speech" + apiKey: ${TTS_API_KEY} model: "tinfoil/voxtral-tts" - voices: ["casual_female"] + voices: ["ar_male", "casual_female", "casual_male", "cheerful_female", "de_female", "de_male", "es_female", "es_male", "fr_female", "fr_male", "hi_female", "hi_male", "it_female", "it_male", "neutral_female", "neutral_male", "nl_female", "nl_male", "pt_female", "pt_male"] stt: openai: - url: "https://gateway.inference.coop/v1" - apiKey: "${STT_API_KEY}" - model: "tinfoil/whisper-large-v3-turbo" + url: "https://gateway.inference.coop/v1/audio/transcriptions" + apiKey: ${STT_API_KEY} + model: "tinfoil/voxtral-small-24b" + # Seeded client defaults (Settings -> Speech): members who never saved + # their own speech settings get the External engines out of the box; + # a member's own saved settings always win. "Automatic playback" stays + # opt-in per member (set textToSpeech.automaticPlayback: true to change). speechTab: conversationMode: false advancedMode: false - speechToText: true - textToSpeech: true + speechToText: + engineSTT: external + # Pin the transcription LANGUAGE default to English. Without it the + # client sends no language param and voxtral-small-24b auto-detects — + # which misfired once as Spanish on a short first mic press (reported + # 2026-11-07). Members who save their own language in Settings -> Speech + # always override this default. + languageSTT: "en" + textToSpeech: + engineTTS: external + voice: casual_female # Web search: self-hosted SearXNG (search.inference.coop, keyless JSON API) # for search, keyless Keenable for page scraping, no reranker. The instance From bb276dd7ddd8bb9c5cae3c594a4767974c43a809 Mon Sep 17 00:00:00 2001 From: Inferencebot Date: Mon, 9 Nov 2026 05:00:31 +0000 Subject: [PATCH 3/6] Pin manifest to 20261106-c2aec74 --- CloudronManifest.json | 112 +++++++++++++++++++++--------------------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/CloudronManifest.json b/CloudronManifest.json index 787d242..83f2575 100644 --- a/CloudronManifest.json +++ b/CloudronManifest.json @@ -1,59 +1,59 @@ { - "id": "ai.librechat.cloudronapp", - "version": "1.4.8", - "title": "LibreChat", - "upstreamVersion": "0.8.8", - "author": "Danny Avila", - "description": "LibreChat is an open-source chatbot client that supports multiple AI providers and models including:\n\n- OpenAI GPT Models\n- Anthropic Claude Models\n- Google PaLM Models\n- Various open-source local models\n\nFeatures:\n- Switch between various AI models\n- Conversation history\n- Plugins support\n- File upload and processing\n- Custom instructions\n- Multiple conversation modes\n\n", - "changelog": "* Update uv to 0.13.5\n", - "tagline": "ChatGPT-like interface with model switching", - "website": "https://github.com/danny-avila/LibreChat", - "documentationUrl": "https://docs.cloudron.io/packages/librechat/", - "forumUrl": "https://forum.cloudron.io/category/210/librechat", - "contactEmail": "support@cloudron.io", - "healthCheckPath": "/health", - "httpPort": 3080, - "addons": { - "postgresql": {}, - "mongodb": {}, - "localstorage": {}, - "oidc": { - "loginRedirectUri": "/oauth/openid/callback" + "id": "ai.librechat.cloudronapp", + "version": "1.4.8", + "title": "LibreChat", + "upstreamVersion": "0.8.8", + "author": "Danny Avila", + "description": "LibreChat is an open-source chatbot client that supports multiple AI providers and models including:\n\n- OpenAI GPT Models\n- Anthropic Claude Models\n- Google PaLM Models\n- Various open-source local models\n\nFeatures:\n- Switch between various AI models\n- Conversation history\n- Plugins support\n- File upload and processing\n- Custom instructions\n- Multiple conversation modes\n\n", + "changelog": "* Update uv to 0.13.5\n", + "tagline": "ChatGPT-like interface with model switching", + "website": "https://github.com/danny-avila/LibreChat", + "documentationUrl": "https://docs.cloudron.io/packages/librechat/", + "forumUrl": "https://forum.cloudron.io/category/210/librechat", + "contactEmail": "support@cloudron.io", + "healthCheckPath": "/health", + "httpPort": 3080, + "addons": { + "postgresql": {}, + "mongodb": {}, + "localstorage": {}, + "oidc": { + "loginRedirectUri": "/oauth/openid/callback" + }, + "sendmail": { + "supportsDisplayName": true + }, + "scheduler": { + "librechat_key_sync": { + "schedule": "* * * * *", + "command": "cd /app/code/librechat/api && node /app/code/sync-keys.js" + } + } }, - "sendmail": { - "supportsDisplayName": true + "checklist": { + "register-admin": { + "message": "On the first visit, register yourself as an admin user" + }, + "disable-registration": { + "message": "Disable registration, if required, to prevent misuse" + }, + "set-api-keys": { + "message": "Set API keys in /app/data/env file and restart the app" + } }, - "scheduler": { - "librechat_key_sync": { - "schedule": "* * * * *", - "command": "cd /app/code/librechat/api && node /app/code/sync-keys.js" - } - } - }, - "checklist": { - "register-admin": { - "message": "On the first visit, register yourself as an admin user" - }, - "disable-registration": { - "message": "Disable registration, if required, to prevent misuse" - }, - "set-api-keys": { - "message": "Set API keys in /app/data/env file and restart the app" - } - }, - "optionalSso": true, - "manifestVersion": 2, - "memoryLimit": 1073741824, - "minBoxVersion": "8.1.0", - "tags": [ - "ai", - "chat", - "gpt" - ], - "mediaLinks": [ - "https://screenshots.cloudron.io/ai.librechat.cloudronapp/librechat-00.png", - "https://screenshots.cloudron.io/ai.librechat.cloudronapp/librechat-01.png" - ], - "icon": "file://logo.png", - "dockerImage": "registry.inference.coop/co-op/librechat-custom:20261031-2a98892" -} \ No newline at end of file + "optionalSso": true, + "manifestVersion": 2, + "memoryLimit": 1073741824, + "minBoxVersion": "8.1.0", + "tags": [ + "ai", + "chat", + "gpt" + ], + "mediaLinks": [ + "https://screenshots.cloudron.io/ai.librechat.cloudronapp/librechat-00.png", + "https://screenshots.cloudron.io/ai.librechat.cloudronapp/librechat-01.png" + ], + "icon": "file://logo.png", + "dockerImage": "registry.inference.coop/co-op/librechat-custom:20261106-c2aec74" +} From 179fd7ce020ecabd7203eb68d18040acf4bf2eb2 Mon Sep 17 00:00:00 2001 From: Inferencebot Date: Wed, 11 Nov 2026 03:55:18 +0000 Subject: [PATCH 4/6] =?UTF-8?q?chat:=20fail-closed=20librechat.yaml=20vali?= =?UTF-8?q?dation=20at=20boot=20=E2=80=94=20insert=20configSchema.strict()?= =?UTF-8?q?=20check=20into=20/app/pkg/start.sh=20at=20build=20time=20(2026?= =?UTF-8?q?-10-31=20customFooter=20outage=20guard)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 10 ++ patch_start_validator.py | 70 +++++++++++ validate_config.py | 261 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 341 insertions(+) create mode 100644 patch_start_validator.py create mode 100644 validate_config.py diff --git a/Dockerfile b/Dockerfile index e0db542..5a3b4ff 100644 --- a/Dockerfile +++ b/Dockerfile @@ -54,6 +54,16 @@ COPY sync-keys.js /app/code/sync-keys.js COPY patch_ui_strings.py /app/code/patch_ui_strings.py RUN python3 /app/code/patch_ui_strings.py +# Fail-closed librechat.yaml validation, inserted into /app/pkg/start.sh at +# BUILD time (the runtime rootfs is read-only). The validator script's +# canonical copy lives in ops-docs/scripts/ — this byte-identical twin ships +# with the image. patch_start_validator.py is non-fatal at build (a missing +# anchor only skips the insert) and idempotent; an INVALID config is fatal at +# RUNTIME by design. Keep validate_config.py's md5 in step with the canonical. +COPY validate_config.py /app/code/validate_config.py +COPY patch_start_validator.py /app/code/patch_start_validator.py +RUN python3 /app/code/patch_start_validator.py + # Inject branding into built HTML (dist) before image is packaged. # patch_index.py: title, custom.css/custom2.js links, and a per-build # x-coop-build meta (unique every build → service worker precache revision diff --git a/patch_start_validator.py b/patch_start_validator.py new file mode 100644 index 0000000..ba4e0f8 --- /dev/null +++ b/patch_start_validator.py @@ -0,0 +1,70 @@ +"""Insert the fail-closed librechat.yaml validation into /app/pkg/start.sh. + +Run at BUILD time (the runtime rootfs is read-only under Cloudron). Non-fatal: +if the anchor line is missing (upstream changed its start script) this prints a +loud note and exits 0 so a LibreChat version bump can never brick the build — +the RUNNING app then simply lacks the pre-boot check until the patch is fixed, +which the deploy verification catches by grepping the boot log. + +Idempotent: the block carries a marker; re-insertion is skipped when present. + +The block validates /app/data/librechat.yaml with the container's own +librechat-data-provider strict schema (the same check the API server runs at +boot, which exits 1 on an unrecognized top-level key — the 2026-10-31 outage). +Placement: after the first-run `touch /app/data/librechat.yaml` and before the +secrets/env assembly, so a bad config stops the boot BEFORE anything starts. +The -s guard skips the empty first-run file; the -f guard keeps a missing +validator non-fatal (patch did not apply). An INVALID config is fatal by +design — that is the point. +""" +import sys + +START = "/app/pkg/start.sh" +ANCHOR = "if [[ ! -f /app/data/librechat.yaml ]]; then touch /app/data/librechat.yaml; fi" +MARKER = "co-op fail-closed librechat.yaml validation" + +BLOCK = """ +# --- {marker} (overlay, 2026-11-11) --- +# Invalid librechat.yaml must stop the boot LOUDLY, naming the offending key, +# before the API server can come half-up (SPA serving 200 while the API is +# down — the 2026-10-31 outage). The venv python carries pyyaml; the schema +# probe runs against the image's own data-provider build. +if [ -f /app/code/validate_config.py ] && [ -s /app/data/librechat.yaml ]; then + echo "Validating librechat.yaml (fail-closed)..." + if ! /app/code/venv/bin/python3 /app/code/validate_config.py librechat /app/data/librechat.yaml; then + echo "FATAL: librechat.yaml is invalid - refusing to start. Fix or remove the offending key named above." >&2 + exit 1 + fi +fi +""".format(marker=MARKER) + + +def main() -> int: + try: + with open(START, encoding="utf-8") as fh: + src = fh.read() + except OSError as exc: + print(f"WARN: cannot read {START}: {exc} — validation patch NOT applied", + flush=True) + return 0 + + if MARKER in src: + print("INFO: validation block already present in start.sh (idempotent skip)", + flush=True) + return 0 + + if ANCHOR not in src: + print("WARN: anchor line not found in /app/pkg/start.sh — validation " + "patch NOT applied; fix patch_start_validator.py after the " + "upstream change", flush=True) + return 0 + + patched = src.replace(ANCHOR, ANCHOR + "\n" + BLOCK.strip("\n") + "\n", 1) + with open(START, "w", encoding="utf-8") as fh: + fh.write(patched) + print(f"INFO: inserted fail-closed config validation into {START}", flush=True) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/validate_config.py b/validate_config.py new file mode 100644 index 0000000..2cb50c7 --- /dev/null +++ b/validate_config.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +"""Fail-closed config validator for the co-op's gateway and chat apps. + +ONE script, two modes, shared home in ops-docs/scripts/ and shipped +byte-identical into both app images (litellm repo root, librechat-custom repo +root). Each app's start path calls it before booting the service; a non-zero +exit refuses the boot with a ONE-line error naming the offending key. + +Why this exists: the 2026-10-31 chat outage. A `customFooter:` top-level key in +librechat.yaml was rejected by LibreChat's strict config validator and the API +server refused to start, while the SPA kept being served with HTTP 200 — the +app looked up but every API route returned the HTML shell. Nothing had ever +checked the config before boot. This validator closes that gap: invalid config +fails LOUD and EARLY, at the top of the boot log, naming the key. + +Modes +----- +litellm Structural check of the gateway's config.yaml: + - top-level keys within LiteLLM's documented config surface; + - model_list present and well-formed (model_name + litellm_params.model); + - the settings blocks are objects; pass_through_endpoints entries have paths. + When the gateway's own litellm package is importable it is additionally + used to resolve every model string to a provider (catches unknown + provider prefixes); the check is skipped with a note where litellm + itself is absent. + +librechat Checks librechat.yaml against the DEPLOYED build's own strict schema: + it runs `configSchema.strict().safeParse()` from the container's + librechat-data-provider via node — the same code the API server runs + at boot (its failure mode is `process.exit(1)`, "Exiting due to + invalid configuration"). Unrecognized top-level keys are rejected, + named explicitly. Where node/the package cannot be found (e.g. this + script run from a checkout instead of the image) it falls back to a + static top-level allowlist recorded from the deployed build and says + so on the failure line. + +Usage +----- + python3 validate_config.py litellm /app/data/config.yaml + python3 validate_config.py librechat /app/data/librechat.yaml + +Exit codes: 0 valid, 1 invalid, 2 usage/environment error (file unreadable, +yaml unparseable). Never prints a value from the config — only key names and +counts, so it is safe to run against files that carry secrets. +""" + +import json +import os +import subprocess +import sys + +# LiteLLM's documented top-level config surface (proxy config). Unknown keys +# are rejected here — the gateway should never silently ignore a mistyped +# section (a "model-list:" typo would otherwise deploy an EMPTY catalog). +LITELLM_TOP_LEVEL = { + "model_list", + "router_settings", + "litellm_settings", + "general_settings", + "settings", + "environment_variables", + "guardrails", + "files", +} + +# Fallback allowlist for librechat mode, recorded 2026-11-11 from the DEPLOYED +# build (chat.inference.coop, overlay 1.4.8) by reading +# configSchema.strict().shape keys. The live schema is always preferred; this +# exists so the validator still fails closed when run outside the container. +LIBRECHAT_TOP_LEVEL_FALLBACK = { + "actions", "balance", "cache", "cloudfront", "endpoints", "fileConfig", + "fileStrategies", "fileStrategy", "filteredTools", "filters", + "imageOutputType", "includedTools", "interface", "langfuse", "mcpServers", + "mcpSettings", "memory", "messageFilter", "modelSpecs", "ocr", "openapi", + "permissions", "rateLimits", "registration", "secureImageLinks", + "skillSync", "speech", "summarization", "transactions", "turnstile", + "version", "webSearch", +} + +LC_DATA_PROVIDER_DIST = os.environ.get( + "LC_DATA_PROVIDER_DIST", + "/app/code/librechat/packages/data-provider/dist/index.js") +LC_JS_YAML = os.environ.get( + "LC_JS_YAML", "/app/code/librechat/node_modules/js-yaml") + + +def fail(key, reason): + """ONE line, naming the offending key, then a non-zero exit.""" + print(f"CONFIG VALIDATION FAILED: {key}: {reason}", flush=True) + sys.exit(1) + + +def load_yaml(path): + try: + import yaml + except ImportError: + print("CONFIG VALIDATION FAILED: pyyaml not available in this python", + flush=True) + sys.exit(2) + try: + with open(path) as fh: + data = yaml.safe_load(fh) + except FileNotFoundError: + print(f"CONFIG VALIDATION FAILED: config file not found: {path}", + flush=True) + sys.exit(2) + except PermissionError: + print(f"CONFIG VALIDATION FAILED: config file unreadable: {path}", + flush=True) + sys.exit(2) + except yaml.YAMLError as exc: + # Do not echo the raw yaml error: it can quote a secret-bearing line. + print("CONFIG VALIDATION FAILED: (root): yaml does not parse", + flush=True) + sys.exit(2) + if data is None: + data = {} + if not isinstance(data, dict): + fail("(root)", "top level must be a mapping") + return data + + +def validate_litellm(path): + cfg = load_yaml(path) + unknown = sorted(set(cfg) - LITELLM_TOP_LEVEL) + if unknown: + fail(", ".join(unknown), "unknown top-level key(s) for litellm " + f"(allowed: {', '.join(sorted(LITELLM_TOP_LEVEL))})") + + model_list = cfg.get("model_list") + if not isinstance(model_list, list) or not model_list: + fail("model_list", "must be a non-empty list of model entries") + names = set() + for i, entry in enumerate(model_list): + if not isinstance(entry, dict): + fail(f"model_list[{i}]", "entry must be a mapping") + name = entry.get("model_name") + params = entry.get("litellm_params") + if not name or not isinstance(name, str): + fail(f"model_list[{i}].model_name", "missing or empty") + if name in names: + fail(f"model_list[{i}].model_name", f"duplicate model_name {name!r}") + names.add(name) + if not isinstance(params, dict) or not params.get("model"): + fail(f"model_list[{i}].litellm_params.model", "missing or empty") + for block in ("router_settings", "litellm_settings", "general_settings"): + if block in cfg and not isinstance(cfg[block], dict): + fail(block, "must be a mapping") + for ep in (cfg.get("general_settings") or {}).get("pass_through_endpoints") or []: + if not isinstance(ep, dict) or not ep.get("path"): + fail("general_settings.pass_through_endpoints", "each entry needs a path") + + # litellm-assisted check (best effort): resolve each model string to a + # provider with the gateway's own package. Skipped where litellm itself + # is not importable (never fatal — the structural checks above ran). + try: + from litellm import get_llm_provider # noqa: WPS433 + except Exception: + print("note: litellm not importable here; provider check skipped", + flush=True) + else: + for entry in model_list: + model = entry["litellm_params"]["model"] + try: + get_llm_provider(model=model, custom_llm_provider=None) + except Exception as exc: + short = str(exc).split("\n")[0][:120] + fail(f"model_list.{entry['model_name']}.litellm_params.model", + f"not resolvable to a provider: {short}") + + print(f"config OK (litellm): {len(cfg)} top-level key(s), " + f"{len(model_list)} model(s) validated", flush=True) + sys.exit(0) + + +def validate_librechat(path): + cfg = load_yaml(path) + if not cfg: + print("config OK (librechat): empty config, nothing to validate", + flush=True) + sys.exit(0) + + # Preferred: the DEPLOYED build's own strict schema, run through node — + # the exact code path the API server uses at boot (strict() rejects + # unrecognized top-level keys; upstream then exits 1). + node_code = r""" +const fs = require('fs'); +let out = {mode: 'schema'}; +try { + const yaml = require(JS_YAML_PATH); + const dp = require(DIST_PATH); + const cfg = yaml.load(fs.readFileSync(CONFIG_PATH, 'utf8')) || {}; + const result = dp.configSchema.strict().safeParse(cfg); + if (result.success) { + out.ok = true; + out.keys = Object.keys(cfg).length; + } else { + out.ok = false; + out.errors = (result.error && result.error.issues || []).slice(0, 10) + .map(i => ({path: (i.path || []).join('.') || '(root)', msg: i.message})); + } +} catch (e) { + out.mode = 'schema-unavailable'; + out.error = String(e && e.message || e).slice(0, 200); +} +console.log('@@' + JSON.stringify(out)); +""".replace("JS_YAML_PATH", json.dumps(LC_JS_YAML)) \ + .replace("DIST_PATH", json.dumps(LC_DATA_PROVIDER_DIST)) \ + .replace("CONFIG_PATH", json.dumps(path)) + + if os.path.exists(LC_DATA_PROVIDER_DIST): + try: + proc = subprocess.run(["node", "-e", node_code], capture_output=True, + text=True, timeout=60) + for line in (proc.stdout or "").splitlines(): + if line.startswith("@@"): + res = json.loads(line[2:]) + if res.get("ok"): + print(f"config OK (librechat): {res['keys']} top-level " + "key(s) accepted by the deployed strict schema", + flush=True) + sys.exit(0) + errs = "; ".join( + f"{e['path']}: {e['msg']}" for e in res.get("errors", [])) + if errs: + fail(errs, "rejected by the deployed build's strict " + "config schema (configSchema.strict())") + fail("(root)", "strict schema rejected the config") + # No @@ line: schema path unavailable — fall through to fallback. + print("note: deployed schema probe produced no result " + f"(stderr: {(proc.stderr or '')[:120]!r})", flush=True) + except (OSError, subprocess.TimeoutExpired) as exc: + print(f"note: could not run node against the deployed schema " + f"({type(exc).__name__})", flush=True) + else: + print("note: deployed data-provider dist not found; using the static " + "fallback allowlist recorded from the deployed build", flush=True) + + # Fallback: static allowlist (still fail-closed). + unknown = sorted(set(cfg) - LIBRECHAT_TOP_LEVEL_FALLBACK) + if unknown: + fail(", ".join(unknown), "unknown top-level key(s) for librechat " + f"(fallback allowlist: {', '.join(sorted(LIBRECHAT_TOP_LEVEL_FALLBACK))})") + print(f"config OK (librechat, fallback allowlist): {len(cfg)} top-level " + "key(s)", flush=True) + sys.exit(0) + + +def main(): + args = sys.argv[1:] + if len(args) != 2 or args[0] not in ("litellm", "librechat"): + print("usage: validate_config.py ", + file=sys.stderr, flush=True) + sys.exit(2) + if args[0] == "litellm": + validate_litellm(args[1]) + validate_librechat(args[1]) + + +if __name__ == "__main__": + main() From 1f5cf342e7bd3d2cc7bfac8200dbf27f6d3d0e96 Mon Sep 17 00:00:00 2001 From: Inferencebot Date: Wed, 11 Nov 2026 03:58:14 +0000 Subject: [PATCH 5/6] Pin manifest to 20261111-179fd7c --- CloudronManifest.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CloudronManifest.json b/CloudronManifest.json index 83f2575..2952fb0 100644 --- a/CloudronManifest.json +++ b/CloudronManifest.json @@ -55,5 +55,5 @@ "https://screenshots.cloudron.io/ai.librechat.cloudronapp/librechat-01.png" ], "icon": "file://logo.png", - "dockerImage": "registry.inference.coop/co-op/librechat-custom:20261106-c2aec74" + "dockerImage": "registry.inference.coop/co-op/librechat-custom:20261111-179fd7c" } From 1ffd62afca56acc7437c2033be717e97e010f997 Mon Sep 17 00:00:00 2001 From: Inferencebot Date: Fri, 13 Nov 2026 15:54:10 +0000 Subject: [PATCH 6/6] chat: add regolo/mistral-small-4-119b + regolo/gemma4-31b (models.default + modelSpecs); web search ON by default per spec Both models are live on the gateway and complete (smoke-called 2026-11-13). webSearch: true on every modelSpec seeds web search ON in new conversations; the member's per-conversation toggle still decides (submit path reads the toggle's own state). Deployed: volume file first (pre-edit backup librechat.yaml.pre-20261113-websearch-defaults on the volume), container restart, live md5 56c92e96 matches this commit; validator green against the deployed strict schema pre-deploy. --- librechat.yaml | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/librechat.yaml b/librechat.yaml index 2f329a9..f383e6a 100644 --- a/librechat.yaml +++ b/librechat.yaml @@ -21,17 +21,30 @@ endpoints: - greenpt/glm-5.3 - regolo/apertus-70b - regolo/qwen3.5-122b + - regolo/mistral-small-4-119b + - regolo/gemma4-31b titleConvo: true titleModel: "greenpt/glm-5.3-flash" titleMethod: "completion" # Emoji-ified model picker (same convention as models.md / OWUI): # 🌱 = renewable (GreenPT + Regolo), 🔒 = TEE-private (Tinfoil). +# webSearch: true per spec = web search ON BY DEFAULT in new conversations +# (client seeds the new-convo tool state from the spec). The member's toggle +# still decides per conversation — the spec value only fills the gap when the +# toggle has never been touched, and the submit path sends the toggle's own +# state (ephemeralAgent?.web_search ?? modelSpec.webSearch). 2026-11-06 these +# defaults were dropped because the then-deployed client re-applied them past +# a member's toggle; on the current build (appstore 1.4.8) the submit path +# reads the toggle's own state — the post-deploy check for THIS default is: +# a fresh conversation starts with web search ON, toggling it off keeps the +# next message search-free, and a new conversation defaults ON again. modelSpecs: enforce: false prioritize: true list: - name: tinfoil-deepseek-v4-1-flash + webSearch: true iconURL: "data:image/png;base64,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" label: "🔒 tinfoil/deepseek-v4-1-flash" softDefault: true @@ -39,47 +52,68 @@ modelSpecs: endpoint: "Inference Co-op" model: "tinfoil/deepseek-v4-1-flash" - name: tinfoil-gpt-oss-120b + webSearch: true iconURL: "data:image/png;base64,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" label: "🔒 tinfoil/gpt-oss-120b" preset: endpoint: "Inference Co-op" model: "tinfoil/gpt-oss-120b" - name: tinfoil-glm-5-3 + webSearch: true iconURL: "data:image/png;base64,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" label: "🔒 tinfoil/glm-5.3" preset: endpoint: "Inference Co-op" model: "tinfoil/glm-5.3" - name: greenpt-deepseek-v4-1-flash + webSearch: true iconURL: "data:image/png;base64,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" label: "🌱 greenpt/deepseek-v4.1-flash" preset: endpoint: "Inference Co-op" model: "greenpt/deepseek-v4.1-flash" - name: greenpt-glm-5-3-flash + webSearch: true iconURL: "data:image/png;base64,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" label: "🌱 greenpt/glm-5.3-flash" preset: endpoint: "Inference Co-op" model: "greenpt/glm-5.3-flash" - name: greenpt-glm-5-3 + webSearch: true iconURL: "data:image/png;base64,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" label: "🌱 greenpt/glm-5.3" preset: endpoint: "Inference Co-op" model: "greenpt/glm-5.3" - name: regolo-apertus-70b + webSearch: true iconURL: "data:image/png;base64,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" label: "🌱 regolo/apertus-70b" preset: endpoint: "Inference Co-op" model: "regolo/apertus-70b" - name: regolo-qwen3-5-122b + webSearch: true iconURL: "data:image/png;base64,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" label: "🌱 regolo/qwen3.5-122b" preset: endpoint: "Inference Co-op" model: "regolo/qwen3.5-122b" + - name: regolo-mistral-small-4-119b + webSearch: true + iconURL: "data:image/png;base64,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" + label: "🌱 regolo/mistral-small-4-119b" + preset: + endpoint: "Inference Co-op" + model: "regolo/mistral-small-4-119b" + - name: regolo-gemma4-31b + webSearch: true + iconURL: "data:image/png;base64,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" + label: "🌱 regolo/gemma4-31b" + preset: + endpoint: "Inference Co-op" + model: "regolo/gemma4-31b" # Inference Cooperative branding interface: