diff --git a/CloudronManifest.json b/CloudronManifest.json index bd94d84..2952fb0 100644 --- a/CloudronManifest.json +++ b/CloudronManifest.json @@ -1,59 +1,59 @@ { - "id": "ai.librechat.cloudronapp", - "version": "1.4.5", - "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" + "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:20261111-179fd7c" } diff --git a/Dockerfile b/Dockerfile index 17ea43d..5a3b4ff 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 @@ -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/librechat.yaml b/librechat.yaml index 2475eaa..0b42eeb 100644 --- a/librechat.yaml +++ b/librechat.yaml @@ -21,12 +21,21 @@ 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). +# NO spec-level webSearch default: per the 2026-11-06 de-force fix, a spec +# webSearch:true re-arms search across the new-conversation -> first-reply +# re-key, past a member's toggle-off (the client's spec seeding for new convos +# takes pure spec values and re-applies them on context re-keys). Default-on +# per conversation therefore needs either that behavior knowingly re-accepted, +# or a small build-time client patch seeding the default only for members who +# never toggled — an operator decision, recorded here until then. modelSpecs: enforce: false prioritize: true @@ -80,6 +89,18 @@ modelSpecs: preset: endpoint: "Inference Co-op" model: "regolo/qwen3.5-122b" + - name: regolo-mistral-small-4-119b + iconURL: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAaK0lEQVR4nO3dPXJTWbQG0EsX1dVVPSmG4CkQkJE4cULihISEhIyAKXgITIoqioQX9LvvycKSrnTPzz5nrxV2G2lLZev7zr6y/Gqhml8/f/zuPQPAyP7+599XvWeYlSd2JyEP0IdysI8n7wrCHiA2pWA7T9QZAh9gbArBaZ6YAwIfYG4Kwf9L/0QIfYCcspeBtA9e8AOwLHmLQKoHLfQBOCdTGUjxQAU/ANfIUASmfoCCH4A9Zi4CUz4wwQ9ASTMWgakekOAHoKaZisAUD0TwA9DSDEVg6Acg+AHoaeQi8FfvAW4l/AHobeQsGq65jPxkAzCv0bYBQ20AhD8AUY2WUUO0ldGeVAByG2EbEH4DIPwBGM0I2RW6AIzwBALAS6JnWMgVRfQnDQCuEfGSQLgNgPAHYDYRsy1UAYj4BAFACdEyLkwBiPbEAEBpkbKu+zWJSE8GALTS+30BXTcAwh+ArHpnYLcC0PuBA0BvPbOwSwEQ/gDwn16Z2LwACH8AeK5HNjYtAMIfAF7WOiObFQDhDwDntczKJgVA+APANq0ys3oBEP4AcJ0W2RnmkwABgHaqFgCnfwC4Te0MrfYxhMIf4nn75d3Z///t/ddGkwBb1frI4Co3Kvwhjkuhf4oyAHHUKAHFb1D4Q3+3hv4pygD0V7oEeBMgTKZ0+Ne6TaCvogXA6R/6qhnUSgD0VTpji60ThD/00zqcXRKAfkpdCiiyARD+0E+Pk7ltAPRTKnO9BwAAEtpdAJz+oZ+eJ3FbAOinRPbuKgDCH/qJEMARZoCs9mawSwAwoEjBG2kWYLubC4DTPwD0tSeLbyoAwh8AYrg1k10CgMFEXLlHnAk47+oC4PQPALHcks02AACQ0FUFwOkf+oq8ao88G2RwbUbbAABAQpsLgNM/AMR2TVbbAABAQpsKgNM/AIxha2bbAABAQhcLgNM/AIxlS3bbAABAQmcLgNM/xPLt/dfeI5wUeTbI6FKG2wAAQEIKAAAkdLIAWP9DTBFX7RFnAs5nuQ0AACT0YgFw+geAOZzKdBsAGFCklXukWYDtFAAYVITgjTADcJs/CoD1P4yjZwALfxjHS9luAwAACSkAMLgeJ3Gnfxjfq+P/4BIAjOvtl3dVb1/ww7j+/uffZ5n/bAMg/GFsNQNa+MPYjjPeJQCYTI2gFv4wn2frABsAmM+tlwWEPszn8DKAAgCJXCoDQh/m9mIBEP4AML+1BHgPAAAkpAAAQEIKAAAkpAAAQEJ/LYs3AAJAFmvm2wAAQEIKAAAkpAAAQEIKAAAkpAAAQEIKAAAk9MqvAAJAPjYAAJCQAgAACSkAAJCQAgAACSkAAJCQAgAACb3uPQBk9vj94+WvefOhwSRANj4HABraEvgXb0MhAApQAKCBEsH/x20qAsAOCgBUVCP4/7gPRQC4gQIAFbQI/j/uUxEAruC3AKCwHuHf836BMSkAUFDvEO59/8A4FAAoJEr4RpkDiM17AKCAiKE7wnsC7p8eTv6/z3efGk4C+SgAsFPE8F9FLAHnQv8UZQDKUwBgh8jhv4pSAm4J/mOKAJTjo4CBqkoE//FtKQKwnzcBwo1GOP0vS985S4Z/i9uFTBQAoIraIa0EwD4KANxglNP/qvW8rcJZCYDbKQAAkJACAFca7fS/ajV361O5LQDcRgEAiukVxkoAXE8BAICEFAC4wqjr/9Xo8wPlKABAEb3X8L3vH0ajAABAQgoAACSkAABAQgoAACSkAABAQgoAACSkAABAQgoAUMTnu0+p7x9GowDAFR7ffOg9wi6jzw+UowAAQEIKAFBMrzW89T9cTwGAK426Rm81d+swFv5wGwUAABJSAOAGo20BWs/b6lTu9A+3UwCAKmqHs/CHfRQAuNEoW4Cec9YKaeEP+73uPQAwtzWs758eit0WsN+rXz9//O49BIzs8fvH3iOcFHFLcUsREPxQngIABUQsARHD/9i5MiD0oS4FAAqJVAJGCH+gL28ChEKihG6UOYDYFAAoqHf49r5/YBwKABTWK4SFP3AN7wGAilq8L0DwA7dQAKCBGkVA8AN7KADQUIkiIPiBEhQA6GhLIRD4QA0KAAAk5LcAACAhBQAAElIAACAhBQAAElIAACAhBQAAElIAACAhBQAAElIAACAhBQAAElIAACAhBQAAEnrdewCI6O2Xd5u+7tv7r5UnAajDXwOEZXvgX6IQAKNQAEitVPAfUwSA6BQAUqoV/McUASAqbwIknVbh3/q+AK5hA0AavcPYNgCIRAEghd7hv+pdAh6/fzz//998aDQJ0JsCwPSihP+qdQm4FPon/50yAFNTAJhatPBf1S4Bt4b+ydtTBmA63gTItKKG/7LUna10+Ne6TaAvGwCmFDn8D5XeBNQO6pE3AfdPD2f//+e7T40mgRh8FDBMoNUJfb2fUYrApdA/9bXKABm4BMB0Rjn9L0uZWXus50e4JHBN+Jf8tzAKGwCmMlL4r95+edf91wNnUiq819uxDWBWNgAwsJ4n8YhbgBond9sAZqUAMI0RT/+rW2aPEMARZljVDGolgBkpADCgSMEbYZYWAa0EMBsFgCmMfPpfzfAYgHEoAMDQWp7MbQGYiQIAg4mwcj/Wa6YegawEMAsFAAASUgAY3kzXzmd6LEBsCgAMJOL6f9V6tp6reJcBmIECAAAJKQAAkJACAAAJKQAAkJACAAAJKQAAkJACAAAJKQAwkMc3H3qPcFLr2T7ffWp6f1HuG0pRABjet/dfe49QzEyPBYhNAQCAhBQAGEzEywC9Zuqxirf+ZxYKADC0loEs/JmJAsAUZrh2PsNjAMahAMCAIl0GiDBLi5O50z+zUQCYxsgn6FtmjxC8EWZY1Qxo4c+MFAAYWM8AjhT+qxpBLfyZ1eveA0BJ395/Xd5+edd7jKuMvLmIaA3s+6eHIrcDs7IBYDojBWqJWXucxCOe/o/tCXDhTwY2ADCBNZAfv39scj+jOAzySxsBoU82r379/PG79xBQQ/RLAbU2FbVKwGjhD5znEgDTinwpoOZsNYJa+MN8bACYXrRNQOticutGQOjD3BQAUohSAnpvJS6VAaEPeSgApNG7BPQOf4BDCgDptC4Cgh+IyJsASadlIAt/ICobAFKrtQ0Q/EB0CgAs5YqA4AdGoQDAC7YWAoEPjEoBAICEvAkQABJSAAAgIQUAABJSAAAgIQUAABJSAAAgIQUAABJSAAAgode9B4Bz7p8eNn3d57tPlScBmItPAiSUrYF/iUIAcJ4CQAilgv+YIgDwMgWArmoF/zFFAOA5BYAuWgX/MUUA4D9+C4DmeoV/7/sGiMQGgGaihe9o24C3X95t+rpv779WngSYgQJAE9HCfxW9BGwN/VOUAeAUBYDqoob/KmIJ2Bv8xxQB4JgCQFXRw38VpQSUDv5jigCwUgCoZpTwX/UuAbXDfzVKCXj8/vHy17z50GASmJOPAoYAWoX/el9RS8CW0D/19coAXMcGgCpGO/2vemwBWob/oUgl4NrgP3tbigBs4nMAKG7U8F+W9rP3Cv/e932oZPjXuD2YlUsA0EmEAO55OaBmUK+3HXEbcK5k9n4fCrm4BEBRI5/+D9V+IY4Q/odal4CWp/QIJeCWnwtlgNpcAoDGooX/srSdqfWKvuclgfunh5tL8Z5/C1soABQz04vVTI+FPkp9D/lepBYFABqKePpftZit12m89f2WDm0lgBoUAIqY8QVqxsfUU+9357e6/1rfN74fKU0BgEYin/5XI8wYWe2QVgIoSQEAqut9+l9FmQMiUAAACmh1OrcFoBQFgN1mfkEq9dhGWq2PNCtwOwUAqCra2r3GPK1L8Mylm3YUAABISAEAgIQUAABISAEAgIQUAABISAEAgIQUAABISAEAqnp886H3CM/UmOfz3afitxnp/piTAsBuM78YlXps395/LXI7LYw0K3A7BQCggFZFeObCTVsKAFBdlMsAUeaACBQAaGSE1foIM0ZW+3Tu9E9JCgBFzPjCNONj6qn36bvV/df6vvH9SGkKADQU+YTdYrZeJaD1/ZYOa+FPDQoAxcz0IjXTY6GPUt9DvhepRQGAxiJuAVrO1Po03vPSw+e7TzcH+J5/C1u8+vXzx+/eQzCX+6eH3iPs0upF9+2Xd03u55JeheTx+8f69xHwXf/nfj4EPi0pABSnAGzXuwRE2EbUKAIRgx+icQmA4kY+xbSevWcARwj/ZSkf1sIftrEBoJrRNgE9i0vrTUCU8D+2Zxsg+OE6r3sPAPwXyK1KQNTwX5bnIb6lDAh9uJ0NAFWNsgWIctmidgmIHP5AWwoA1UUvAVHC/1DpIiD4gWMKAE1ELQERw//Q3iIg+IFTFACaiVYCoof/sa1lQOgDWygANNe7CIwW/AA1+BwAmusZwMIf4D82AHTVahsg+AGeUwAIoVYREPwAL1MACKVUERD8AOcpAIS2tRAIfIDrKAAAkJDfAgCAhBQAAEhIAQCAhBQAAEjode8BGIfPogeYh98C4KRSf5JWIQCIRwHgmdJ/h/6YMgAQgwLAsiz1g/+YIgDQlwKQXOvgP6YIAPThtwAS6x3+UWYAyMgGIKlowTvqJuDx+8dtX/fmQ+VJAK6jACQTLfiPjVAEtob+yX+vDAABKACJRA//VcQSsDf0T96uMgB04j0ASYwS/ssSb9Za4V/7tgHOsQFIIFqgbtV7E9A6nEfcBtw/PZz9/5/vPjWaBLiWjwKGF/Q4mT9+/zhECbgU+qe+VhmAWGwAJjfq6X/VYwvQey0fsQRcE/pbKAPQn/cATGz08F+W9o+hd/hHmeFQ6fCvdZvAdWwAJjVD+B9qsQmIFrwRNgG1gzryJuDSz1Dv96jAXgrApBSA60QL/1WvEtD6hB6lCNz6c6MMMCIFYEKzhf+q1ots1PBftS4BvdbzvUvA3p+bEUrApe/1CFsn2vFbAEBqpQrzejsRi8Dmj6z+369TBHKwAZjMrKf/VekX1+in/1WrF+Teb85rvQWo9fMSpQT42GrO8VsApDVK+C9Lm1l7h3/rGWqW5QhFvMT3zEg/I1xPAQBChP+qxSwtArpnCSgZ3ErAvBSAiUQ4ddSW4THCHjUCWwmYkwJASiO+oI04c0QtS+RMH2Tl+28+CgAkF2n9v6o1U48Nkq0VUSkAABNocUK3BZiLAjCJTKeMvY915BexkWcHYlEAILGI6/9V6dl6luTa992yGCqh81AAACAhBQAAElIAACAhBQAAElIAACAhBQAAElIAACAhBQAS+3z3qfcIJ5We7dv7r0VvL9J9P775UPX2e90XdSkAk+j54tba3sc68gvYyLMDsSgAABNoUQ4V0LkoAJBcxMsAtWbqsSnLtJ1jLAoAKY14khlx5ohaBnLr8K/5PeL7bz4KwEQynDQyPEbYo0ZQC/85KQBAqMsALWZpUSR7ltWSgS3856UAkNZIL2wtZo1QAlrOUDOgI2yqSnzPjPQzwvVe/fr543fvISir5989r6nWi2r0v2/e+kX4/umh6f2tehWQ0j8vEcL/2LXf44I/h9e9BwDoaQ3svUUgYvCv1kC/VAQEfy42AJOabQtQ/ZPUgm4Ber0gt94CRLj8sCy3/9xEDn84RQGYlAJwvWglIMJprHYRiBL8L7n0MyT0GZ0CMLFZSkDLF9ooJSBC+K9qlYDI4Q8Z+C2Aic1wQpnpg1RGmuFQjaAW/tCfDUACo24Cuv4edadNQLTwf8mtGwGhD7H4LQB4weObD81LwAjhvyzPg/xSGRD6EJcNQBKjbQEiXb6oXQRGCX5gLt4DkESkQL0k2qz+wAowIxuAZKJvAqKF/0v2bgSEPhCBApBUtCIwQvC/ZGsZEPpANApAYlFKwKjhDzAy7wFILELwRpgBICMbAJZlab8NEPwAfSkAPFO7CAh+gBgUAE4qVQaEPkA8CgCbbS0EAh8gPgUAABLyWwAAkJACAAAJKQAAkJACAAAJKQAAkJACAAAJve49AJxz//Sw6es+332qPAnAXHwOAKFsDfxLFAKA8xQAQigV/McUAYCXKQB0VSv4jykCAM8pAHTTKvxXo5cAf4sBKEkBoLnWwX9spCKw9y8yKgPAKQoATfUO/1X0ElDqTzGvFAHgmAJAM1HCfxWxBJQO/mOKALBSAGgiWvivIpWA2uG/GqUEPH7/ePlr3nxoMAnMSQGguqjhv4pQAlqF/ypqCdgS+if/rTIAV1EAqCp6+K96loDW4b+KVAL2BP8ft6UIwCb+FgB01Cv8e9/3oZLhX+P2YFY2AFQzyul/1XoLECWAe20CWgR1xG3AuZ+LCJejyEMBoIrRwn/V6gU4SvivWpeAlqf0CCXglp8HZYDaXAKAxqKF/7K0nan1ir73JYFby/CoJZpxKAAUN/IL18izE8v908Pu76cStwGnKADQUMTT/6rFbL1O463vt3RoKwHUoABQ1AwvVDM8hoh6r+Jb3X+t7x/fl5SmAEAjkU//qxFmBMpQAIDqep/+V7XnqH1KtwWgJAUAoIBW4awEUIoCQDEzvTCVfiwjrdZHmhW4nQIAVBVl/b+KNg/0ogAA7NR6+zXTto1+FAAASEgBAICEFAAASEgBAICEFAAASEgBAICEFACgqsc3H3qP8EyNeT7ffSp+m5HujzkpABQz04tS6cfy7f3XordX00izArdTAAAgIQUAqC7KZYCac7TagM20aaMvBQAaGWG1PsKMkdUOZ+FPSQoARc3wAjXDY4io9xag9/1DNAoANBT5hN1itl4h3PJ+axVIxZTSFACKG/mFauTZiaP095HvS2pQAKCxiFuAljO13gL02jp8vvu0O7hL3AacogBQxYgvWi1njlQCeszSKpQjXPe/9ftqxJ8hxvLq188fv3sPwbzunx56j7BJrxfbt1/edbnfVYQi8vj9Y/nbDBD8p5z7mRD6tKQAUJUCcFmvEhAh/FclS0Dk8IdIFACqi14CIpy6WpeASOF/aE8REPxwHQWAJqKWgAjhv2pVAqKG/7EtZUDow+0UAJqJVgIihf+qdgkYJfyB+hQAmopSAiKG/6HSRUDwA8cUAJrrXQKih/+hvUVA8AOnKAB007oIjBT8L9laBoQ+sIUCQFetSsDo4Q9QmgJACLWKgOAHeJkCQCilioDgBzhPASC0rYVA4ANcRwEAgIT8NUAASEgBAICEFAAASEgBAICEFAAASEgBAICEFAAASEgBAICEFAAASEgBAICEFAAASEgBAICEFAAASEgBAICEXvceACJ6++Xdpq/79v5r5UkA6nj16+eP372HgAi2hv4pygAwEgWA9PYG/zFFABiBAkBapYP/mCIARKYAkFLt8F9FKwGP3z+e//9vPjSaBOhNASCdVuG/6l0CLoX+yX+nDMDUFABSaR3+qx4l4Nbg/+N2FAGYks8BII1e4d/jvkuFf+nbAuKwASCFnuF/qPYmoHZYj7wNuH96OPv/P999ajQJxKAAML0o4b+qVQJandRHKwGXgv+YIkAWCgBTixb+q9IloPWafoQScG3wH1MEmJ33AADT2Rv+pW4DIlMAmFbU0/+ylJ2tx5v0Ir8xsGRwKwHMTAGAgfUM4ogloEZgKwHM6q+///n3Ve8hoLTIp//VCDOOpGZQKwHM5u9//n1lAwCDinACjzADcBsFABheixO6LQCzUQCYzkir9ZFmBeaiAMCAIq3eI80CbKcAAENruZp3GYCZKAAAkNBfy/LfrwP0HgQAqG/NfBsAAEhIAQCAhBQAAEhIAQCAhP6vAHgjIIzj8c2H3iP8n96zfL77NOV9QQ2HWW8DwHS+vf/ae4TNRpoVmIsCAAAJKQAwqN6r9ygzLEub1bz1P7N5VgC8D4BZjLBaH2FGYB7HGW8DAAPreQKPcvpf1TyhO/0zIwWAaUU+YZecrUcQRwv/VY2gFv7MSgEAplIysIU/M/ujAHgfADOJuAWoMVPLE3nU0/+hEsEt/JnJS9n+Ytj/+vnjd/1xoJ23X971HmFZlvqF5PH7x7q3P0D4H7t/erjq6wU/M1IASK13CWi5jShdBEYM/mOXioDgZ2abC8CyKAHMqVcJ6HEpolQJmCH8IbNTl/YVANJpXQJ6vw/h1iIg+GEOVxeAZVECmFerEtA7/I9dKgNCH+Zy7o39CgBp1S4B0cIfyEcBgDNKFwHBD0RxcwFYFiWAPPYWAcEPRHLpc30UAHjB1jIg9IGodheAZVECAGAkWz7V198CAICENhUAfx8AAMawNbNtAAAgoc0FwBYAAGK7JqttAAAgoasKgC0AAMR0bUbbAABAQlcXAFsAAIjllmy2AQCAhG4qALYAABDDrZl88wZACQCAvvZksUsAAJDQrgJgCwAAfezN4N0bACUAANoqkb0uAQBAQkUKgC0AALRRKnOLbQCUAACoq2TWFr0EoAQAQB2lM9Z7AAAgoeIFwBYAAMqqka1VNgBKAACUUStTq10CUAIAYJ+aWVr1PQBKAADcpnaGehMgACRUvQDYAgDAdVpkZ5MNgBIAANu0ysxmlwCUAAA4r2VWNn0PgBIAAC9rnZHN3wSoBADAcz2ysctvASgBAPCfXpnY7dcAlQAAsuuZhV0/B0AJACCr3hkYJoB//fzxu/cMAFBb7+BfhfkkwChPCADUEinrwhSAZYn1xABASdEyLlQBWJZ4TxAA7BUx28INdMj7AgAYWcTgX4XbAByK/MQBwDnRMyx0AViW+E8gABwbIbvCD3jIJQEAIhsh+FfhNwCHRnpiAchltIwaathDtgEARDBa8K+G2gAcGvUJB2AeI2fRsIMfsg0AoKWRg381/AM4pAgAUNMMwb+a5oEcUgQAKGmm4F9N94AOKQIA7DFj8K+mfWCHFAEArjFz8K+mf4CHFAEAzskQ/Ks0D/SYMgDAsuQK/UMpH/QhRQAgp6zBv0r94I8pAwBzyx76hzwRZygEAGMT+Kd5Yq6gEADEJvC380TtpBQA9CHs9/HkVaQcAOwj5Ov5H2rOEm8J8Jj7AAAAAElFTkSuQmCC" + label: "🌱 regolo/mistral-small-4-119b" + preset: + endpoint: "Inference Co-op" + model: "regolo/mistral-small-4-119b" + - name: regolo-gemma4-31b + 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: @@ -166,6 +187,12 @@ speech: advancedMode: false 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 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/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; } 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()