Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
✒️ fix: Bind Assistant Avatar Updates to Authorized Owners (#17391)
lia-by-librechat[bot]39ecd5563ca7
diff --git a/api/server/controllers/assistants/v1.js b/api/server/controllers/assistants/v1.jsindex 61a61522cc..f84c16ec9b 100644--- a/api/server/controllers/assistants/v1.js+++ b/api/server/controllers/assistants/v1.js@@ -8,13 +8,23 @@ const {contentFilterUninspectableResponse,getBlockedUninspectableFileField,resolveAssistantToolPermissions,+ getAssistantErrorStatus,+ resolveAssistantAvatarIdentity,+ commitAssistantAvatar,} = require('@librechat/api');const { FileContext } = require('librechat-data-provider');const {deleteFileByFilter,updateAssistantDoc,+ updateAssistantAvatar,getAssistants,+ getAssistant,getRoleByName,+ getUserById,+ getFiles,+ acquireResourceLock,+ renewResourceLock,+ releaseResourceLock,} = require('~/models');const { uploadImageBuffer, filterFile } = require('~/server/services/Files/process');const validateAuthor = require('~/server/middleware/assistants/validateAuthor');@@ -402,75 +412,64 @@ const uploadAssistantAvatar = async (req, res) => {}const { assistant_id } = req.params;- const endpoint = req.body?.endpoint ?? req.query?.endpoint;if (!assistant_id) {return res.status(400).json({ message: 'Assistant ID is required' });}const { openai } = await getOpenAIClient({ req, res });- await validateAuthor({ req, openai });-- const buffer = await fs.readFile(req.file.path);- const image = await uploadImageBuffer({+ const assistantQuery = await validateAuthor({req,- context: FileContext.avatar,- metadata: { buffer },+ openai,+ overrideAssistantId: assistant_id,});- let _metadata;-- try {- const assistant = await openai.beta.assistants.retrieve(assistant_id);- if (assistant) {- _metadata = assistant.metadata;- }- } catch (error) {- logger.error('[/:assistant_id/avatar] Error fetching assistant', error);- _metadata = {};- }-- if (_metadata.avatar && _metadata.avatar_source) {- const { deleteFile } = getStrategyFunctions(_metadata.avatar_source);- try {- await deleteFile(req, {- filepath: _metadata.avatar,- user: req.user.id,- tenantId: req.user.tenantId,- });- await deleteFileByFilter({ user: req.user.id, filepath: _metadata.avatar });- } catch (error) {- logger.error('[/:assistant_id/avatar] Error deleting old avatar', error);- }- }-- const metadata = {- ..._metadata,- avatar: image.filepath,- avatar_source: appConfig.fileStrategy,- };+ const assistant = await openai.beta.assistants.retrieve(assistant_id);+ const _metadata = assistant.metadata ?? {};+ const avatarIdentity = await resolveAssistantAvatarIdentity({+ query: assistantQuery,+ user: req.user,+ endpoint: req.body?.endpoint ?? req.query?.endpoint,+ author: _metadata.author,+ privateAssistants:+ req.config.endpoints?.[req.body?.endpoint ?? req.query?.endpoint]?.privateAssistants,+ getAssistant,+ getUserById,+ });- const promises = [];- promises.push(- updateAssistantDoc(- { assistantId: assistant_id },- {- avatar: {- filepath: image.filepath,- source: appConfig.fileStrategy,- },- user: req.user.id,- endpoint,+ const updatedAssistant = await commitAssistantAvatar(+ {+ req,+ query: assistantQuery,+ identity: avatarIdentity,+ uploadAvatar: async () => {+ const buffer = await fs.readFile(req.file.path);+ const image = await uploadImageBuffer({+ req,+ context: FileContext.avatar,+ metadata: { buffer },+ });+ return { filepath: image.filepath, source: image.source ?? appConfig.fileStrategy };},- ),+ metadata: _metadata,+ leaseOptions: {+ ttlMs: req.config.config?.permissions?.leaseTtlMs,+ waitMs: req.config.config?.permissions?.leaseWaitMs,+ },+ },+ {+ lease: { acquireResourceLock, renewResourceLock, releaseResourceLock },+ updateAssistantAvatar,+ updateProvider: (id, body) => openai.beta.assistants.update(id, body),+ getFiles,+ deleteFileByFilter,+ getStrategyFunctions,+ },);- promises.push(openai.beta.assistants.update(assistant_id, { metadata }));-- const resolved = await Promise.all(promises);- res.status(201).json(resolved[1]);+ res.status(201).json(updatedAssistant);} catch (error) {const message = 'An error occurred while updating the Assistant Avatar';logger.error(message, error);- res.status(500).json({ message });+ res.status(getAssistantErrorStatus(error)).json({ message });} finally {try {await fs.unlink(req.file.path);diff --git a/api/server/middleware/assistants/validateAuthor.js b/api/server/middleware/assistants/validateAuthor.jsindex 07cda1c9e3..f416c3be9c 100644--- a/api/server/middleware/assistants/validateAuthor.js+++ b/api/server/middleware/assistants/validateAuthor.js@@ -1,50 +1,5 @@-const { logger, SystemCapabilities } = require('@librechat/data-schemas');+const { createAssistantAuthorValidator } = require('@librechat/api');const { hasCapability } = require('~/server/middleware/roles/capabilities');const { getAssistant } = require('~/models');-/**- * Checks if the assistant is supported or excluded- * @param {object} params- * @param {object} params.req - Express Request- * @param {object} params.req.body - The request payload.- * @param {OpenAIClient} params.openai - OpenAI API Client- * @returns {Promise<void>}- */-const validateAuthor = async ({ req, openai }) => {- const endpoint = req.body.endpoint ?? req.query.endpoint;- const assistant_id = req.params.id ?? req.body.assistant_id ?? req.query.assistant_id;-- const appConfig = req.config;- /** @type {Partial<TAssistantEndpoint>} */- const assistantsConfig = appConfig.endpoints?.[endpoint];- if (!assistantsConfig) {- return;- }-- if (!assistantsConfig.privateAssistants) {- return;- }-- let canManageAssistants = false;- try {- canManageAssistants = await hasCapability(req.user, SystemCapabilities.MANAGE_ASSISTANTS);- } catch (err) {- logger.warn(`[validateAuthor] capability check failed, denying bypass: ${err.message}`);- }-- if (canManageAssistants) {- logger.debug(`[validateAuthor] MANAGE_ASSISTANTS bypass for user ${req.user.id}`);- return;- }-- const assistantDoc = await getAssistant({ assistantId: assistant_id, user: req.user.id });- if (assistantDoc) {- return;- }- const assistant = await openai.beta.assistants.retrieve(assistant_id);- if (req.user.id !== assistant?.metadata?.author) {- throw new Error(`Assistant ${assistant_id} is not authored by the user.`);- }-};--module.exports = validateAuthor;+module.exports = createAssistantAuthorValidator({ getAssistant, hasCapability });diff --git a/api/server/middleware/spec/validateImages.spec.js b/api/server/middleware/spec/validateImages.spec.jsindex f0b7e16e3f..314df807fb 100644--- a/api/server/middleware/spec/validateImages.spec.js+++ b/api/server/middleware/spec/validateImages.spec.js@@ -317,7 +317,7 @@ describe('validateImageRequest middleware', () => {'/images/65cfb246f7ecadb8b1e8036c/assistant-avatar.png?manual=true',],},- { _id: 1, assistant_id: 1, endpoint: 1 },+ { _id: 1, assistant_id: 1, endpoint: 1, user: 1 },);});diff --git a/api/server/routes/assistants/avatar.spec.js b/api/server/routes/assistants/avatar.spec.jsnew file mode 100644index 0000000000..4518a265a8--- /dev/null+++ b/api/server/routes/assistants/avatar.spec.js@@ -0,0 +1,694 @@+const os = require('os');+const fs = require('fs').promises;+const jwt = require('jsonwebtoken');+const multer = require('multer');+const express = require('express');+const mongoose = require('mongoose');+const request = require('supertest');+const { MongoMemoryServer } = require('mongodb-memory-server');+const { createImageAuthorizationMiddleware } = require('@librechat/api');+const { createModels, tenantStorage } = require('@librechat/data-schemas');++jest.mock('~/models', () => require('@librechat/data-schemas').createMethods(require('mongoose')));+jest.mock('~/server/middleware/roles/capabilities', () => ({ hasCapability: jest.fn() }));+jest.mock('~/server/services/Files/process', () => ({+ filterFile: jest.fn(),+ uploadImageBuffer: jest.fn(),+}));+jest.mock('~/server/services/Files/strategies', () => ({ getStrategyFunctions: jest.fn() }));+jest.mock('~/server/services/ActionService', () => ({ deleteAssistantActions: jest.fn() }));+jest.mock('~/server/services/MCP', () => ({}));+jest.mock('~/app/clients/tools', () => ({ manifestToolMap: {} }));+jest.mock('~/server/controllers/assistants/helpers', () => ({+ getOpenAIClient: jest.fn(),+ fetchAssistants: jest.fn(),+}));+jest.mock('./actions', () => require('express').Router());+jest.mock('./documents', () => require('express').Router());+jest.mock('./tools', () => require('express').Router());++const { hasCapability } = require('~/server/middleware/roles/capabilities');+const { uploadImageBuffer } = require('~/server/services/Files/process');+const { getStrategyFunctions } = require('~/server/services/Files/strategies');+const { getOpenAIClient } = require('~/server/controllers/assistants/helpers');+const { updateAssistantDoc } = require('~/models');+const { avatar } = require('./v1');++const attacker = new mongoose.Types.ObjectId();+const victim = new mongoose.Types.ObjectId();+const png = Buffer.from(+ 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=',+ 'base64',+);++describe('assistant avatar multipart authorization', () => {+ let mongo;+ let directory;+ let Assistant;+ let app;+ let providers;+ let privateAssistants;+ let requestUser;+ let User;+ let File;+ const retrieve = jest.fn();+ const update = jest.fn();+ const deleteStoredFile = jest.fn();+ const openai = { beta: { assistants: { retrieve, update } } };++ beforeAll(async () => {+ directory = await fs.mkdtemp(`${os.tmpdir()}/assistant-avatar-`);+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });+ await mongoose.connect(mongo.getUri());+ mongoose.set('strictQuery', true);+ ({ Assistant, User, File } = createModels(mongoose));+ await User.init();+ const upload = multer({ dest: directory });+ app = express();+ // Authenticated user/config fixture; exercise real multipart parsing, route, guard and DB.+ app.use((req, _res, next) => {+ req.user = { id: requestUser.toString(), role: 'USER', tenantId: 'tenant-a' };+ req.config = {+ fileStrategy: 'local',+ endpoints: { assistants: { privateAssistants } },+ };+ next();+ });+ app.post('/api/files/images/assistants/:assistant_id/avatar', upload.single('file'));+ app.use((req, _res, next) => {+ tenantStorage.run({ tenantId: req.user.tenantId }, next);+ });+ app.use('/api/files/images/assistants', avatar);+ app.get(+ '/images/:user/:filename',+ createImageAuthorizationMiddleware(+ { secureImageLinks: true },+ {+ parseCookies: (header) => Object.fromEntries([header.split('=')]),+ isOpenIdReuseEnabled: () => false,+ getBasePath: () => '',+ findSession: async () => ({ id: 'test-session' }),+ getUserById: async () => ({ role: 'USER', tenantId: 'tenant-a' }),+ getAgent: async () => null,+ getAssistant: require('~/models').getAssistant,+ getImageConfig: async () => ({+ secureImageLinks: true,+ assistantEndpoints: [+ { endpoint: 'assistants', privateAssistants },+ { endpoint: 'azureAssistants', privateAssistants: true },+ ],+ }),+ getUserPrincipals: async () => [],+ hasCapabilityForPrincipals: async () => false,+ hasPermission: async () => false,+ },+ ),+ (_req, res) => res.sendStatus(200),+ );+ });++ afterAll(async () => {+ await mongoose.disconnect();+ await mongo?.stop();+ await fs.rm(directory, { recursive: true, force: true });+ });++ beforeEach(async () => {+ jest.clearAllMocks();+ privateAssistants = true;+ requestUser = attacker;+ await User.deleteMany({});+ await User.collection.insertMany([+ { _id: attacker, email: '[email protected]', tenantId: 'tenant-a' },+ { _id: victim, email: '[email protected]', tenantId: 'tenant-a' },+ ]);+ await Assistant.deleteMany({});+ await File.deleteMany({});+ await Assistant.create([+ {+ assistant_id: 'asst-attacker',+ user: attacker,+ endpoint: 'assistants',+ tenantId: 'tenant-a',+ },+ { assistant_id: 'asst-victim', user: victim, endpoint: 'assistants', tenantId: 'tenant-a' },+ {+ assistant_id: 'asst-other-tenant',+ user: attacker,+ endpoint: 'assistants',+ tenantId: 'tenant-b',+ },+ ]);+ providers = {+ 'asst-attacker': { id: 'asst-attacker', metadata: { author: attacker.toString() } },+ 'asst-victim': {+ id: 'asst-victim',+ instructions: 'private victim configuration',+ metadata: { author: victim.toString() },+ },+ 'asst-other-tenant': {+ id: 'asst-other-tenant',+ metadata: { author: victim.toString() },+ },+ };+ retrieve.mockImplementation(async (id) => providers[id]);+ update.mockImplementation(async (id, data) => ({ ...providers[id], ...data }));+ hasCapability.mockResolvedValue(false);+ getOpenAIClient.mockResolvedValue({ openai });+ uploadImageBuffer.mockResolvedValue({ filepath: '/images/avatar.png' });+ deleteStoredFile.mockReset().mockImplementation(async (req, file) => {+ if (req.user.id !== file.user.toString() || req.user.tenantId !== file.tenantId) {+ throw new Error('Stored avatar owner mismatch');+ }+ });+ getStrategyFunctions.mockReturnValue({ deleteFile: deleteStoredFile });+ });++ async function upload(id, fields = {}, query = '', checkTemporaryFiles = true) {+ let req = request(app)+ .post(`/api/files/images/assistants/${id}/avatar${query}`)+ .field('endpoint', 'assistants');+ for (const [key, value] of Object.entries(fields)) {+ req = req.field(key, value);+ }+ const response = await req.attach('file', png, {+ filename: 'avatar.png',+ contentType: 'image/png',+ });+ if (checkTemporaryFiles) {+ expect(await fs.readdir(directory)).toEqual([]);+ }+ return response;+ }++ async function expectVictimUnchanged() {+ const doc = await Assistant.findOne({ assistant_id: 'asst-victim' }).lean();+ expect(doc.user.toString()).toBe(victim.toString());+ expect(doc.avatar).toBeUndefined();+ expect(update).not.toHaveBeenCalled();+ expect(uploadImageBuffer).not.toHaveBeenCalled();+ }++ it('denies the victim route with omitted body and query IDs despite an unrelated owned assistant', async () => {+ const response = await upload('asst-victim');+ expect(response.status).not.toBe(201);+ expect(response.body).not.toHaveProperty('instructions');+ expect(retrieve).toHaveBeenCalledWith('asst-victim');+ expect(retrieve).not.toHaveBeenCalledWith(undefined);+ await expectVictimUnchanged();+ });++ it.each([+ [{ assistant_id: 'asst-attacker' }, ''],+ [{}, '?assistant_id=asst-attacker'],+ [{ assistant_id: 'asst-victim' }, '?assistant_id=asst-attacker'],+ [{}, '?assistant_id=asst-victim&assistant_id=asst-attacker'],+ ])('rejects conflicting or malformed secondary selectors: %p %s', async (fields, query) => {+ const response = await upload('asst-victim', fields, query);+ expect(response.status).toBe(400);+ expect(retrieve).not.toHaveBeenCalled();+ await expectVictimUnchanged();+ });++ it('allows an owner upload without redundant selectors and preserves ownership', async () => {+ const response = await upload('asst-attacker');+ expect(response.status).toBe(201);+ const doc = await Assistant.findOne({ assistant_id: 'asst-attacker' }).lean();+ expect(doc.user.toString()).toBe(attacker.toString());+ expect(doc.endpoint).toBe('assistants');+ expect(doc.avatar).toEqual({ filepath: '/images/avatar.png', source: 'local' });+ expect(update).toHaveBeenCalledWith('asst-attacker', {+ metadata: {+ author: attacker.toString(),+ avatar: '/images/avatar.png',+ avatar_source: 'local',+ },+ });+ });++ it('accepts matching multipart and query IDs', async () => {+ const response = await upload(+ 'asst-attacker',+ { assistant_id: 'asst-attacker' },+ '?assistant_id=asst-attacker',+ );+ expect(response.status).toBe(201);+ });++ it('allows management without transferring the victim document ownership', async () => {+ hasCapability.mockResolvedValue(true);+ const filepath = `/images/${attacker}/managed-avatar.png`;+ uploadImageBuffer.mockResolvedValue({ filepath });+ const response = await upload('asst-victim');+ expect(response.status).toBe(201);+ const doc = await Assistant.findOne({ assistant_id: 'asst-victim' }).lean();+ expect(doc.user.toString()).toBe(victim.toString());+ expect(doc.avatar).toEqual({ filepath, source: 'local' });+ const token = jwt.sign({ id: victim.toString() }, process.env.JWT_REFRESH_SECRET, {+ expiresIn: '1h',+ });+ const image = await request(app).get(filepath).set('Cookie', `refreshToken=${token}`);+ expect(image.status).toBe(200);+ const unrelatedToken = jwt.sign(+ { id: new mongoose.Types.ObjectId().toString() },+ process.env.JWT_REFRESH_SECRET,+ { expiresIn: '1h' },+ );+ const denied = await request(app).get(filepath).set('Cookie', `refreshToken=${unrelatedToken}`);+ expect(denied.status).toBe(403);+ });++ it('creates a reference for a provider-only private assistant after verifying its author', async () => {+ providers['asst-provider-only'] = {+ id: 'asst-provider-only',+ metadata: { author: attacker.toString() },+ };+ const response = await upload('asst-provider-only');+ expect(response.status).toBe(201);+ const doc = await Assistant.findOne({ assistant_id: 'asst-provider-only' }).lean();+ expect(doc.user.toString()).toBe(attacker.toString());+ expect(doc).toMatchObject({+ endpoint: 'assistants',+ tenantId: 'tenant-a',+ avatar: { filepath: '/images/avatar.png', source: 'local' },+ });+ });++ it.each([false, true])(+ 'preserves the provider author after a manager initializes an ownerless reference: %p',+ async (existingReference) => {+ if (existingReference) {+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ updateAssistantDoc(+ { assistantId: 'asst-managed-provider' },+ { conversation_starters: ['Hello'] },+ ),+ );+ }+ providers['asst-managed-provider'] = {+ id: 'asst-managed-provider',+ metadata: { author: victim.toString() },+ };+ hasCapability.mockResolvedValue(true);+ const managedPath = `/images/${attacker}/provider-avatar.png`;+ uploadImageBuffer.mockResolvedValue({ filepath: managedPath });+ const managedResponse = await upload('asst-managed-provider');+ expect(managedResponse.status).toBe(201);+ const reference = await Assistant.findOne({ assistant_id: 'asst-managed-provider' }).lean();+ expect(reference.user.toString()).toBe(victim.toString());+ const token = jwt.sign({ id: victim.toString() }, process.env.JWT_REFRESH_SECRET, {+ expiresIn: '1h',+ });+ const image = await request(app).get(managedPath).set('Cookie', `refreshToken=${token}`);+ expect(image.status).toBe(200);++ requestUser = victim;+ hasCapability.mockResolvedValue(false);+ providers['asst-managed-provider'] = managedResponse.body;+ const ownerPath = `/images/${victim}/owner-avatar.png`;+ uploadImageBuffer.mockResolvedValue({ filepath: ownerPath });+ // Keep the fixture focused on persistence rather than the old-storage deletion service.+ delete providers['asst-managed-provider'].metadata.avatar;+ delete providers['asst-managed-provider'].metadata.avatar_source;+ const ownerResponse = await upload('asst-managed-provider');+ expect(ownerResponse.status).toBe(201);+ const updated = await Assistant.findOne({ assistant_id: 'asst-managed-provider' }).lean();+ expect(updated.user.toString()).toBe(victim.toString());+ expect(updated.avatar.filepath).toBe(ownerPath);+ expect(await Assistant.countDocuments({ assistant_id: 'asst-managed-provider' })).toBe(1);+ },+ );++ it.each([+ [false, 'missing'],+ [true, 'missing'],+ [false, 'malformed'],+ [true, 'malformed'],+ [false, 'unavailable'],+ [true, 'unavailable'],+ [false, 'foreign'],+ [true, 'foreign'],+ [false, 'retrieve-failed'],+ [true, 'retrieve-failed'],+ ])(+ 'does not initialize a private managed reference without a verified author (existing=%p, %s)',+ async (existingReference, scenario) => {+ const id = 'asst-unverified-provider';+ if (existingReference) {+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ updateAssistantDoc({ assistantId: id }, { conversation_starters: ['Hello'] }),+ );+ }+ const unknownAuthor = new mongoose.Types.ObjectId();+ if (scenario === 'foreign') {+ await User.collection.insertOne({+ _id: unknownAuthor,+ email: '[email protected]',+ tenantId: 'tenant-b',+ });+ }+ providers[id] = {+ id,+ metadata:+ scenario === 'missing'+ ? {}+ : {+ author: scenario === 'malformed' ? 'invalid-author' : unknownAuthor.toString(),+ },+ };+ hasCapability.mockResolvedValue(true);+ if (scenario === 'retrieve-failed') {+ retrieve.mockRejectedValueOnce(new Error('provider unavailable'));+ }+ const response = await upload(id);+ expect(response.status).toBe(500);+ const reference = await Assistant.findOne({ assistant_id: id }).lean();+ if (existingReference) {+ expect(reference.user).toBeUndefined();+ expect(reference.avatar).toBeUndefined();+ expect(reference.conversation_starters).toEqual(['Hello']);+ } else {+ expect(reference).toBeNull();+ }+ expect(update).not.toHaveBeenCalled();+ expect(uploadImageBuffer).not.toHaveBeenCalled();++ providers[id].metadata = { author: victim.toString() };+ const retried = await upload(id);+ expect(retried.status).toBe(201);+ const initialized = await Assistant.findOne({ assistant_id: id }).lean();+ expect(initialized.user.toString()).toBe(victim.toString());+ expect(await Assistant.countDocuments({ assistant_id: id })).toBe(1);+ },+ );++ it('uses the existing private reference owner when provider author metadata is absent', async () => {+ hasCapability.mockResolvedValue(true);+ providers['asst-victim'].metadata = {};+ const response = await upload('asst-victim');+ expect(response.status).toBe(201);+ const reference = await Assistant.findOne({ assistant_id: 'asst-victim' }).lean();+ expect(reference.user.toString()).toBe(victim.toString());+ expect(reference.avatar.filepath).toBe('/images/avatar.png');+ });++ it('does not mutate an existing reference or upload storage when provider retrieval fails', async () => {+ hasCapability.mockResolvedValue(true);+ retrieve.mockRejectedValueOnce(new Error('provider unavailable'));+ const response = await upload('asst-victim');+ expect(response.status).toBe(500);+ await expectVictimUnchanged();+ });++ it('deletes replaced avatars under their persisted owners after cross-owner replacements', async () => {+ const originalPath = `/images/${victim}/original-avatar.png`;+ const managedPath = `/images/${attacker}/managed-avatar.png`;+ const ownerPath = `/images/${victim}/latest-avatar.png`;+ await Assistant.updateOne(+ { assistant_id: 'asst-victim' },+ {+ $set: { avatar: { filepath: originalPath, source: 'local' } },+ },+ );+ await File.collection.insertMany([+ {+ file_id: 'original-avatar',+ filepath: originalPath,+ user: victim,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ },+ {+ file_id: 'managed-avatar',+ filepath: managedPath,+ user: attacker,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ },+ {+ file_id: 'latest-avatar',+ filepath: ownerPath,+ user: victim,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ },+ ]);+ providers['asst-victim'].metadata = {+ author: victim.toString(),+ avatar: originalPath,+ avatar_source: 'local',+ };+ hasCapability.mockResolvedValue(true);+ uploadImageBuffer.mockResolvedValue({ filepath: managedPath, source: 'local' });+ const managed = await upload('asst-victim');+ expect(managed.status).toBe(201);+ expect(deleteStoredFile).toHaveBeenLastCalledWith(+ expect.objectContaining({ user: expect.objectContaining({ id: victim.toString() }) }),+ expect.objectContaining({ file_id: 'original-avatar', filepath: originalPath }),+ );+ expect(await File.findOne({ file_id: 'original-avatar' }).lean()).toBeNull();+ expect(await File.findOne({ file_id: 'managed-avatar' }).lean()).not.toBeNull();++ requestUser = victim;+ hasCapability.mockResolvedValue(false);+ providers['asst-victim'] = managed.body;+ uploadImageBuffer.mockResolvedValue({ filepath: ownerPath, source: 'local' });+ const owned = await upload('asst-victim');+ expect(owned.status).toBe(201);+ expect(deleteStoredFile).toHaveBeenLastCalledWith(+ expect.objectContaining({ user: expect.objectContaining({ id: attacker.toString() }) }),+ expect.objectContaining({ file_id: 'managed-avatar', filepath: managedPath }),+ );+ expect(await File.findOne({ file_id: 'managed-avatar' }).lean()).toBeNull();+ expect(await File.findOne({ file_id: 'latest-avatar' }).lean()).not.toBeNull();+ const assistant = await Assistant.findOne({ assistant_id: 'asst-victim' }).lean();+ expect(assistant.user.toString()).toBe(victim.toString());+ expect(assistant.avatar.filepath).toBe(ownerPath);+ });++ it('preserves the old file and skips provider mutation when avatar persistence fails', async () => {+ const oldAvatar = { filepath: `/images/${attacker}/previous-avatar.png`, source: 'local' };+ await Assistant.updateOne({ assistant_id: 'asst-attacker' }, { $set: { avatar: oldAvatar } });+ providers['asst-attacker'].metadata = {+ author: attacker.toString(),+ avatar: oldAvatar.filepath,+ avatar_source: 'local',+ };+ await File.collection.insertOne({+ file_id: 'previous-avatar',+ filepath: oldAvatar.filepath,+ user: attacker,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ });+ const mutate = jest.spyOn(Assistant, 'findOneAndUpdate').mockImplementationOnce(() => {+ throw new Error('Assistant identity changed');+ });+ try {+ const response = await upload('asst-attacker');+ expect(response.status).toBe(500);+ expect(update).not.toHaveBeenCalled();+ expect(deleteStoredFile).not.toHaveBeenCalled();+ expect(await File.findOne({ file_id: 'previous-avatar' }).lean()).not.toBeNull();+ const reference = await Assistant.findOne({ assistant_id: 'asst-attacker' }).lean();+ expect(reference.avatar).toEqual(oldAvatar);+ } finally {+ mutate.mockRestore();+ }+ });++ it('serializes overlapping provider commits and keeps the final avatar readable', async () => {+ const originalPath = `/images/${attacker}/original.png`;+ const firstPath = `/images/${attacker}/first.png`;+ const secondPath = `/images/${attacker}/second.png`;+ await Assistant.updateOne(+ { assistant_id: 'asst-attacker' },+ {+ $set: { avatar: { filepath: originalPath, source: 'local' } },+ },+ );+ await File.collection.insertMany([+ {+ file_id: 'original-overlap',+ filepath: originalPath,+ user: attacker,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ },+ {+ file_id: 'first-overlap',+ filepath: firstPath,+ user: attacker,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ },+ {+ file_id: 'second-overlap',+ filepath: secondPath,+ user: attacker,+ tenantId: 'tenant-a',+ source: 'local',+ context: 'avatar',+ },+ ]);+ providers['asst-attacker'].metadata = {+ author: attacker.toString(),+ avatar: originalPath,+ avatar_source: 'local',+ };+ let finishFirst;+ let signalFirst;+ const firstStarted = new Promise((resolve) => {+ signalFirst = resolve;+ });+ const firstResponse = new Promise((resolve) => {+ finishFirst = resolve;+ });+ let providerAvatar = originalPath;+ update.mockImplementation(async (id, { metadata }) => {+ if (metadata.avatar === firstPath) {+ signalFirst();+ await firstResponse;+ }+ providerAvatar = metadata.avatar;+ return { id, metadata };+ });+ uploadImageBuffer+ .mockResolvedValueOnce({ filepath: firstPath, source: 'local' })+ .mockResolvedValueOnce({ filepath: secondPath, source: 'local' });+ const first = upload('asst-attacker', {}, '', false);+ await firstStarted;+ const second = upload('asst-attacker', {}, '', false);+ setTimeout(finishFirst, 5);+ const responses = await Promise.all([first, second]);+ expect(await fs.readdir(directory)).toEqual([]);+ expect(responses.map((response) => response.status)).toEqual([201, 201]);+ expect(providerAvatar).toBe(secondPath);+ const reference = await Assistant.findOne({ assistant_id: 'asst-attacker' }).lean();+ expect(reference.avatar.filepath).toBe(providerAvatar);+ expect(await File.findOne({ filepath: providerAvatar }).lean()).not.toBeNull();+ expect(await File.findOne({ filepath: originalPath }).lean()).toBeNull();+ expect(await File.findOne({ filepath: firstPath }).lean()).toBeNull();+ });++ it('keeps the owner of an existing shared assistant when another user changes its avatar', async () => {+ privateAssistants = false;+ const response = await upload('asst-victim');+ expect(response.status).toBe(201);+ const doc = await Assistant.findOne({ assistant_id: 'asst-victim' }).lean();+ expect(doc.user.toString()).toBe(victim.toString());+ expect(doc.avatar).toEqual({ filepath: '/images/avatar.png', source: 'local' });+ expect(await Assistant.countDocuments({ assistant_id: 'asst-victim' })).toBe(1);+ });++ it('keeps provider-only shared avatars accessible to another authenticated user', async () => {+ privateAssistants = false;+ providers['asst-provider-only'] = { id: 'asst-provider-only', metadata: {} };+ const filepath = `/images/${attacker}/shared-avatar.png`;+ uploadImageBuffer.mockResolvedValue({ filepath });++ const response = await upload('asst-provider-only');+ expect(response.status).toBe(201);+ const token = jwt.sign({ id: victim.toString() }, process.env.JWT_REFRESH_SECRET, {+ expiresIn: '1h',+ });+ const image = await request(app).get(filepath).set('Cookie', `refreshToken=${token}`);+ expect(image.status).toBe(200);+ const doc = await Assistant.findOne({ assistant_id: 'asst-provider-only' }).lean();+ expect(doc).toMatchObject({+ endpoint: 'assistants',+ avatar: { filepath, source: 'local' },+ tenantId: 'tenant-a',+ });+ expect(doc.user.toString()).toBe(attacker.toString());+ });++ it('backfills an action-created reference so a shared avatar remains accessible', async () => {+ privateAssistants = false;+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ updateAssistantDoc(+ { assistantId: 'asst-action-created' },+ { user: victim, actions: ['example-action'] },+ ),+ );+ providers['asst-action-created'] = { id: 'asst-action-created', metadata: {} };+ const filepath = `/images/${attacker}/action-avatar.png`;+ uploadImageBuffer.mockResolvedValue({ filepath });++ const response = await upload('asst-action-created');+ expect(response.status).toBe(201);+ const token = jwt.sign({ id: victim.toString() }, process.env.JWT_REFRESH_SECRET, {+ expiresIn: '1h',+ });+ const image = await request(app).get(filepath).set('Cookie', `refreshToken=${token}`);+ expect(image.status).toBe(200);+ const doc = await Assistant.findOne({ assistant_id: 'asst-action-created' }).lean();+ expect(doc.user.toString()).toBe(victim.toString());+ expect(doc).toMatchObject({ endpoint: 'assistants', actions: ['example-action'] });+ });++ it('initializes an ownerless reference only after the provider author check succeeds', async () => {+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ updateAssistantDoc(+ { assistantId: 'asst-ownerless' },+ { conversation_starters: ['Hello'], append_current_datetime: true },+ ),+ );+ providers['asst-ownerless'] = {+ id: 'asst-ownerless',+ metadata: { author: attacker.toString() },+ };++ const response = await upload('asst-ownerless');+ expect(response.status).toBe(201);+ expect(retrieve).toHaveBeenCalledWith('asst-ownerless');+ const doc = await Assistant.findOne({ assistant_id: 'asst-ownerless' }).lean();+ expect(doc.user.toString()).toBe(attacker.toString());+ expect(doc).toMatchObject({+ endpoint: 'assistants',+ conversation_starters: ['Hello'],+ append_current_datetime: true,+ avatar: { filepath: '/images/avatar.png', source: 'local' },+ });+ expect(await Assistant.countDocuments({ assistant_id: 'asst-ownerless' })).toBe(1);+ });++ it('does not claim an ownerless reference when the provider author differs', async () => {+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ updateAssistantDoc({ assistantId: 'asst-ownerless' }, { conversation_starters: ['Hello'] }),+ );+ providers['asst-ownerless'] = {+ id: 'asst-ownerless',+ metadata: { author: victim.toString() },+ };+ const response = await upload('asst-ownerless');+ expect(response.status).not.toBe(201);+ const doc = await Assistant.findOne({ assistant_id: 'asst-ownerless' }).lean();+ expect(doc.user).toBeUndefined();+ expect(doc.avatar).toBeUndefined();+ expect(update).not.toHaveBeenCalled();+ expect(uploadImageBuffer).not.toHaveBeenCalled();+ });++ it('does not authorize using an owned assistant in another tenant', async () => {+ const response = await upload('asst-other-tenant');+ expect(response.status).not.toBe(201);+ expect(update).not.toHaveBeenCalled();+ expect(uploadImageBuffer).not.toHaveBeenCalled();+ const doc = await Assistant.findOne({ assistant_id: 'asst-other-tenant' }).lean();+ expect(doc.avatar).toBeUndefined();+ });++ it('does not upload or mutate when the selected provider cannot access the victim', async () => {+ retrieve.mockRejectedValue(new Error('provider scope denied'));+ const response = await upload('asst-victim');+ expect(response.status).not.toBe(201);+ await expectVictimUnchanged();+ });+});diff --git a/api/server/routes/assistants/chatV1.js b/api/server/routes/assistants/chatV1.jsindex 46820cde56..2117dce2b5 100644--- a/api/server/routes/assistants/chatV1.js+++ b/api/server/routes/assistants/chatV1.js@@ -1,5 +1,9 @@const express = require('express');-const { createMessageFilterPii, reportLocatorTraversalFailure } = require('@librechat/api');+const {+ createMessageFilterPii,+ reportLocatorTraversalFailure,+ validateAssistantId,+} = require('@librechat/api');const router = express.Router();const { handleAbort, validateModel, buildEndpointOption } = require('~/server/middleware');@@ -29,6 +33,7 @@ const filterMessageContent = createMessageFilterPii({router.post('/',filterMessageContent,+ validateAssistantId,validateModel,buildEndpointOption,validateAssistant,diff --git a/api/server/routes/assistants/chatV2.js b/api/server/routes/assistants/chatV2.jsindex 6e105539a9..6d43e997eb 100644--- a/api/server/routes/assistants/chatV2.js+++ b/api/server/routes/assistants/chatV2.js@@ -1,5 +1,9 @@const express = require('express');-const { createMessageFilterPii, reportLocatorTraversalFailure } = require('@librechat/api');+const {+ createMessageFilterPii,+ reportLocatorTraversalFailure,+ validateAssistantId,+} = require('@librechat/api');const router = express.Router();const { handleAbort, validateModel, buildEndpointOption } = require('~/server/middleware');@@ -29,6 +33,7 @@ const filterMessageContent = createMessageFilterPii({router.post('/',filterMessageContent,+ validateAssistantId,validateModel,buildEndpointOption,validateAssistant,diff --git a/api/server/routes/assistants/contentFilter.spec.js b/api/server/routes/assistants/contentFilter.spec.jsindex 43d2b62d49..02f2550c54 100644--- a/api/server/routes/assistants/contentFilter.spec.js+++ b/api/server/routes/assistants/contentFilter.spec.js@@ -7,6 +7,7 @@ const mockCreateAssistantV1 = jest.fn((_req, res) => res.status(201).json({ versconst mockPatchAssistantV1 = jest.fn((_req, res) => res.status(200).json({ version: 1 }));const mockCreateAssistantV2 = jest.fn((_req, res) => res.status(201).json({ version: 2 }));const mockPatchAssistantV2 = jest.fn((_req, res) => res.status(200).json({ version: 2 }));+const mockDeleteAssistant = jest.fn((_req, res) => res.status(204).end());jest.mock('~/server/controllers/assistants/chatV1', () => mockChatV1);jest.mock('~/server/controllers/assistants/chatV2', () => mockChatV2);@@ -14,7 +15,7 @@ jest.mock('~/server/controllers/assistants/v1', () => ({createAssistant: mockCreateAssistantV1,patchAssistant: mockPatchAssistantV1,retrieveAssistant: jest.fn(),- deleteAssistant: jest.fn(),+ deleteAssistant: mockDeleteAssistant,listAssistants: jest.fn(),uploadAssistantAvatar: jest.fn(),}));@@ -53,6 +54,49 @@ function createApp(router, config) {}describe('assistant route content filters', () => {+ it.each([+ ['./v1', 'patch', mockPatchAssistantV1],+ ['./v2', 'patch', mockPatchAssistantV2],+ ['./v1', 'delete', mockDeleteAssistant],+ ['./v2', 'delete', mockDeleteAssistant],+ ])(+ 'rejects conflicting selectors on %s %s before the controller',+ async (route, method, controller) => {+ const module = require(route);+ const app = createApp(module.v1 ?? module, {});+ const response = await request(app)+ [method]('/asst-target?assistant_id=private-submitted-id')+ .send({});+ expect(response.status).toBe(400);+ expect(response.body).toEqual({+ error: 'invalid_assistant_id',+ message: 'Conflicting Assistant IDs',+ });+ expect(JSON.stringify(response.body)).not.toContain('private-submitted-id');+ expect(controller).not.toHaveBeenCalled();+ },+ );++ it.each([+ ['./chatV1', mockChatV1],+ ['./chatV2', mockChatV2],+ ])(+ 'rejects missing and malformed chat selectors on %s before streaming',+ async (route, controller) => {+ const app = createApp(require(route), {});+ for (const body of [{}, { assistant_id: ['private-submitted-id'] }, { assistant_id: '' }]) {+ const response = await request(app).post('/').send(body);+ expect(response.status).toBe(400);+ expect(response.body.error).toBe('invalid_assistant_id');+ expect(JSON.stringify(response.body)).not.toContain('private-submitted-id');+ }+ expect(controller).not.toHaveBeenCalled();+ const accepted = await request(app).post('/').send({ assistant_id: 'asst-valid' });+ expect(accepted.status).toBe(204);+ expect(controller).toHaveBeenCalledTimes(1);+ },+ );+beforeEach(() => {jest.clearAllMocks();});diff --git a/api/server/routes/assistants/v1.js b/api/server/routes/assistants/v1.jsindex d82a2f2431..796119e9a8 100644--- a/api/server/routes/assistants/v1.js+++ b/api/server/routes/assistants/v1.js@@ -1,6 +1,7 @@const express = require('express');const {reportLocatorTraversalFailure,+ validateAssistantId,createContentFilter,extractAssistantContent,} = require('@librechat/api');@@ -63,7 +64,7 @@ router.get('/:id', controllers.retrieveAssistant);* @param {AssistantUpdateParams} req.body - The assistant update parameters.* @returns {Assistant} 200 - success response - application/json*/-router.patch('/:id', filterAssistantContent, controllers.patchAssistant);+router.patch('/:id', filterAssistantContent, validateAssistantId, controllers.patchAssistant);/*** Deletes an assistant.@@ -71,7 +72,7 @@ router.patch('/:id', filterAssistantContent, controllers.patchAssistant);* @param {string} req.params.id - Assistant identifier.* @returns {Assistant} 200 - success response - application/json*/-router.delete('/:id', controllers.deleteAssistant);+router.delete('/:id', validateAssistantId, controllers.deleteAssistant);/*** Returns a list of assistants.diff --git a/api/server/routes/assistants/v2.js b/api/server/routes/assistants/v2.jsindex 4af1dea42a..4dde03b04c 100644--- a/api/server/routes/assistants/v2.js+++ b/api/server/routes/assistants/v2.js@@ -1,6 +1,7 @@const express = require('express');const {reportLocatorTraversalFailure,+ validateAssistantId,createContentFilter,extractAssistantContent,} = require('@librechat/api');@@ -65,7 +66,7 @@ router.get('/:id', v1.retrieveAssistant);* @param {AssistantUpdateParams} req.body - The assistant update parameters.* @returns {Assistant} 200 - success response - application/json*/-router.patch('/:id', filterAssistantContent, v2.patchAssistant);+router.patch('/:id', filterAssistantContent, validateAssistantId, v2.patchAssistant);/*** Deletes an assistant.@@ -73,7 +74,7 @@ router.patch('/:id', filterAssistantContent, v2.patchAssistant);* @param {string} req.params.id - Assistant identifier.* @returns {Assistant} 200 - success response - application/json*/-router.delete('/:id', v1.deleteAssistant);+router.delete('/:id', validateAssistantId, v1.deleteAssistant);/*** Returns a list of assistants.diff --git a/packages/api/src/assistants/author.spec.ts b/packages/api/src/assistants/author.spec.tsnew file mode 100644index 0000000000..9742695013--- /dev/null+++ b/packages/api/src/assistants/author.spec.ts@@ -0,0 +1,280 @@+import { SystemCapabilities } from '@librechat/data-schemas';+import {+ AssistantIdValidationError,+ getAssistantErrorStatus,+ createAssistantAuthorValidator,+ resolveAssistantAvatarIdentity,+} from './author';+import {+ ResourcePermissionsBusyError,+ ResourcePermissionsUnavailableError,+} from '../acl/accessControlService';++const makeRequest = () => ({+ params: {} as { id?: unknown; assistant_id?: unknown },+ body: { endpoint: 'assistants' } as { endpoint: string; assistant_id?: unknown },+ query: {} as { assistant_id?: unknown },+ user: { id: 'user-attacker', role: 'USER', tenantId: 'tenant-a' },+ config: { endpoints: { assistants: { privateAssistants: true } } },+});++describe('assistant author validation', () => {+ const getAssistant = jest.fn();+ const hasCapability = jest.fn();+ const retrieve = jest.fn();+ const openai = { beta: { assistants: { retrieve } } };+ const validateAuthor = createAssistantAuthorValidator({ getAssistant, hasCapability });++ beforeEach(() => {+ getAssistant.mockReset().mockResolvedValue(null);+ hasCapability.mockReset().mockResolvedValue(false);+ retrieve.mockReset().mockResolvedValue({ metadata: { author: 'user-victim' } });+ });++ it('rejects an omitted ID before any capability, database, or provider lookup', async () => {+ await expect(validateAuthor({ req: makeRequest(), openai })).rejects.toThrow(+ 'Assistant ID is required',+ );+ expect(hasCapability).not.toHaveBeenCalled();+ expect(getAssistant).not.toHaveBeenCalled();+ expect(retrieve).not.toHaveBeenCalled();+ });++ it('classifies only typed selector errors as client failures', () => {+ const error = new AssistantIdValidationError('Invalid Assistant ID');+ expect(error.code).toBe('invalid_assistant_id');+ expect(getAssistantErrorStatus(error)).toBe(400);+ expect(getAssistantErrorStatus(new ResourcePermissionsBusyError())).toBe(409);+ expect(getAssistantErrorStatus(new ResourcePermissionsUnavailableError())).toBe(503);+ expect(getAssistantErrorStatus(new Error('database unavailable'))).toBe(500);+ expect(getAssistantErrorStatus({ code: 'invalid_assistant_id' })).toBe(500);+ });++ it.each(['', ' ', 'asst victim', ['asst-victim'], { $ne: null }, 42, null])(+ 'rejects a malformed ID: %p',+ async (assistantId) => {+ const req = makeRequest();+ req.body.assistant_id = assistantId;+ await expect(validateAuthor({ req, openai })).rejects.toThrow('Invalid Assistant ID');+ expect(getAssistant).not.toHaveBeenCalled();+ expect(retrieve).not.toHaveBeenCalled();+ },+ );++ it.each(['body', 'query'] as const)('rejects a conflicting %s selector', async (source) => {+ const req = makeRequest();+ req.params.assistant_id = 'asst-victim';+ req[source].assistant_id = 'asst-attacker';+ await expect(+ validateAuthor({ req, openai, overrideAssistantId: 'asst-victim' }),+ ).rejects.toThrow('Conflicting Assistant IDs');+ expect(hasCapability).not.toHaveBeenCalled();+ expect(getAssistant).not.toHaveBeenCalled();+ expect(retrieve).not.toHaveBeenCalled();+ });++ it('uses the avatar route target rather than an unrelated owned assistant', async () => {+ const req = makeRequest();+ req.params.assistant_id = 'asst-victim';+ getAssistant.mockImplementation(async ({ assistantId }) =>+ assistantId === 'asst-attacker' ? {} : null,+ );+ await expect(validateAuthor({ req, openai })).rejects.toThrow(+ 'Assistant is not authored by the user',+ );+ expect(getAssistant).toHaveBeenCalledWith({+ assistantId: 'asst-victim',+ user: 'user-attacker',+ });+ expect(retrieve).toHaveBeenCalledWith('asst-victim');+ });++ it.each(['route', 'body', 'query'])('supports the existing %s selector', async (source) => {+ const req = makeRequest();+ if (source === 'route') {+ req.params.id = 'asst-attacker';+ } else if (source === 'body') {+ req.body.assistant_id = 'asst-attacker';+ } else {+ req.query.assistant_id = 'asst-attacker';+ }+ getAssistant.mockResolvedValue({});+ await expect(validateAuthor({ req, openai })).resolves.toEqual({+ assistantId: 'asst-attacker',+ user: 'user-attacker',+ });+ expect(retrieve).not.toHaveBeenCalled();+ });++ it('accepts matching selectors and returns the owner-scoped mutation query', async () => {+ const req = makeRequest();+ req.params.assistant_id = 'asst-attacker';+ req.body.assistant_id = 'asst-attacker';+ req.query.assistant_id = 'asst-attacker';+ getAssistant.mockResolvedValue({});+ await expect(+ validateAuthor({ req, openai, overrideAssistantId: 'asst-attacker' }),+ ).resolves.toEqual({ assistantId: 'asst-attacker', user: 'user-attacker' });+ });++ it('preserves the provider author fallback for an exact resource', async () => {+ const req = makeRequest();+ req.params.id = 'asst-attacker';+ retrieve.mockResolvedValue({ metadata: { author: 'user-attacker' } });+ await expect(validateAuthor({ req, openai })).resolves.toEqual({+ assistantId: 'asst-attacker',+ user: 'user-attacker',+ });+ });++ it('preserves the explicit management capability bypass', async () => {+ const req = makeRequest();+ req.params.assistant_id = 'asst-victim';+ hasCapability.mockResolvedValue(true);+ await expect(validateAuthor({ req, openai })).resolves.toEqual({+ assistantId: 'asst-victim',+ });+ expect(hasCapability).toHaveBeenCalledWith(req.user, SystemCapabilities.MANAGE_ASSISTANTS);+ expect(getAssistant).not.toHaveBeenCalled();+ expect(retrieve).not.toHaveBeenCalled();+ });++ it('does not grant a bypass when the capability service fails', async () => {+ const req = makeRequest();+ req.params.id = 'asst-victim';+ hasCapability.mockRejectedValue(new Error('capability service unavailable'));+ await expect(validateAuthor({ req, openai })).rejects.toThrow(+ 'Assistant is not authored by the user',+ );+ expect(getAssistant).toHaveBeenCalledWith({ assistantId: 'asst-victim', user: req.user.id });+ });++ it('propagates database failures rather than falling back to provider authority', async () => {+ const req = makeRequest();+ req.params.id = 'asst-victim';+ getAssistant.mockRejectedValue(new Error('database unavailable'));+ await expect(validateAuthor({ req, openai })).rejects.toThrow('database unavailable');+ expect(retrieve).not.toHaveBeenCalled();+ });++ it('preserves shared-assistant policy without widening the resource selector', async () => {+ const req = makeRequest();+ req.params.assistant_id = 'asst-shared';+ req.config.endpoints.assistants.privateAssistants = false;+ await expect(validateAuthor({ req, openai })).resolves.toEqual({+ assistantId: 'asst-shared',+ });+ expect(hasCapability).not.toHaveBeenCalled();+ expect(getAssistant).not.toHaveBeenCalled();+ });+});++describe('assistant avatar identity', () => {+ const author = '65cfb246f7ecadb8b1e8036c';+ const user = { id: '65cfb246f7ecadb8b1e8036b', tenantId: 'tenant-a' };+ const getUserById = jest.fn();+ const getAssistant = jest.fn();+ const resolveIdentity = (+ query: { user?: string },+ providerAuthor: unknown = author,+ privateAssistants = true,+ ) =>+ resolveAssistantAvatarIdentity({+ query: { assistantId: 'asst-target', ...query },+ user,+ endpoint: 'assistants',+ author: providerAuthor,+ privateAssistants,+ getAssistant,+ getUserById,+ });++ beforeEach(() => {+ getUserById.mockReset().mockResolvedValue({ tenantId: 'tenant-a' });+ getAssistant.mockReset().mockResolvedValue(null);+ });++ it('initializes a managed reference with the same-tenant provider author', async () => {+ await expect(resolveIdentity({})).resolves.toEqual({ user: author, endpoint: 'assistants' });+ expect(getUserById).toHaveBeenCalledWith(author, 'tenantId');+ expect(getAssistant).not.toHaveBeenCalled();+ });++ it.each([null, { tenantId: 'tenant-b' }, {}])(+ 'rejects private initialization for an unavailable or foreign-tenant author: %p',+ async (account) => {+ getUserById.mockResolvedValue(account);+ await expect(resolveIdentity({})).rejects.toThrow('Assistant owner could not be verified');+ expect(getAssistant).toHaveBeenCalledWith({ assistantId: 'asst-target' }, { user: 1 });+ },+ );++ it('retains the authorized owner scope without a redundant lookup', async () => {+ await expect(resolveIdentity({ user: user.id })).resolves.toEqual({+ user: user.id,+ endpoint: 'assistants',+ });+ expect(getUserById).not.toHaveBeenCalled();+ expect(getAssistant).not.toHaveBeenCalled();+ });++ it.each([null, '', 'external-author', ['65cfb246f7ecadb8b1e8036c'], { $ne: null }])(+ 'does not initialize a private reference from an invalid provider author: %p',+ async (providerAuthor) => {+ await expect(resolveIdentity({}, providerAuthor)).rejects.toThrow(+ 'Assistant owner could not be verified',+ );+ expect(getUserById).not.toHaveBeenCalled();+ expect(getAssistant).toHaveBeenCalledWith({ assistantId: 'asst-target' }, { user: 1 });+ },+ );++ it('uses the authenticated provider author without another user read', async () => {+ await expect(resolveIdentity({}, user.id)).resolves.toEqual({+ user: user.id,+ endpoint: 'assistants',+ });+ expect(getAssistant).not.toHaveBeenCalled();+ expect(getUserById).not.toHaveBeenCalled();+ });++ it('preserves a known local owner when provider metadata is absent', async () => {+ getAssistant.mockResolvedValue({ user: author });+ await expect(resolveIdentity({}, null)).resolves.toEqual({+ user: author,+ endpoint: 'assistants',+ });+ });++ it.each([{}, { user: null }, { user: '' }])(+ 'does not initialize an ownerless private reference: %p',+ async (reference) => {+ getAssistant.mockResolvedValue(reference);+ await expect(resolveIdentity({}, null)).rejects.toThrow(+ 'Assistant owner could not be verified',+ );+ },+ );++ it.each([null, '', 'external-author', ['65cfb246f7ecadb8b1e8036c'], { $ne: null }])(+ 'preserves shared-assistant policy without adopting an invalid author: %p',+ async (providerAuthor) => {+ await expect(resolveIdentity({}, providerAuthor, false)).resolves.toEqual({+ user: user.id,+ endpoint: 'assistants',+ });+ expect(getAssistant).not.toHaveBeenCalled();+ expect(getUserById).not.toHaveBeenCalled();+ },+ );++ it('propagates a user lookup failure instead of adopting an unverified author', async () => {+ getUserById.mockRejectedValue(new Error('user database unavailable'));+ await expect(resolveIdentity({})).rejects.toThrow('user database unavailable');+ });++ it('propagates a reference lookup failure instead of adopting the manager', async () => {+ getAssistant.mockRejectedValue(new Error('assistant database unavailable'));+ await expect(resolveIdentity({}, null)).rejects.toThrow('assistant database unavailable');+ });+});diff --git a/packages/api/src/assistants/author.ts b/packages/api/src/assistants/author.tsnew file mode 100644index 0000000000..b7e2c991c3--- /dev/null+++ b/packages/api/src/assistants/author.ts@@ -0,0 +1,187 @@+import { logger, SystemCapabilities } from '@librechat/data-schemas';+import type { RequestHandler } from 'express';+import type { CapabilityUser, HasCapabilityFn } from '../middleware/capabilities';+import {+ ResourcePermissionsBusyError,+ ResourcePermissionsUnavailableError,+} from '../acl/accessControlService';++interface AssistantAuthorRequest {+ params: { id?: unknown; assistant_id?: unknown };+ body?: { endpoint?: string; assistant_id?: unknown };+ query?: { endpoint?: string; assistant_id?: unknown };+ user: CapabilityUser;+ config: { endpoints?: Record<string, { privateAssistants?: boolean } | undefined> };+}++interface AssistantAuthorInput {+ req: AssistantAuthorRequest;+ openai: {+ beta: {+ assistants: {+ retrieve: (id: string) => Promise<{ metadata?: { author?: string } | null }>;+ };+ };+ };+ overrideAssistantId?: string;+}++interface AssistantAuthorQuery {+ assistantId: string;+ user?: string;+}++interface AssistantAuthorDeps {+ getAssistant: (query: { assistantId: string; user: string }) => Promise<object | null>;+ hasCapability: HasCapabilityFn;+}++interface AssistantAvatarIdentityInput {+ query: { assistantId: string; user?: string };+ user: Pick<CapabilityUser, 'id' | 'tenantId'>;+ endpoint: string;+ author?: unknown;+ privateAssistants?: boolean;+ getAssistant: (+ query: { assistantId: string },+ projection: { user: 1 },+ ) => Promise<{ user?: { toString(): string } | null } | null>;+ getUserById: (id: string, select: string) => Promise<{ tenantId?: string } | null>;+}++/** Provider authors initialize references; populated local identity remains authoritative. */+export async function resolveAssistantAvatarIdentity({+ query,+ user,+ endpoint,+ author,+ privateAssistants,+ getAssistant,+ getUserById,+}: AssistantAvatarIdentityInput): Promise<{ user: string; endpoint: string }> {+ const identity = { user: query.user ?? user.id, endpoint };+ if (query.user !== undefined || author === user.id) {+ return identity;+ }+ if (typeof author === 'string' && /^[a-f0-9]{24}$/i.test(author)) {+ const providerAuthor = await getUserById(author, 'tenantId');+ if (providerAuthor && providerAuthor.tenantId === user.tenantId) {+ return { user: author, endpoint };+ }+ }+ if (!privateAssistants) {+ return identity;+ }+ const reference = await getAssistant({ assistantId: query.assistantId }, { user: 1 });+ const owner = reference?.user?.toString();+ if (!owner || !/^[a-f0-9]{24}$/i.test(owner)) {+ throw new Error('Assistant owner could not be verified');+ }+ return { user: owner, endpoint };+}++export class AssistantIdValidationError extends Error {+ readonly code = 'invalid_assistant_id';++ constructor(message: string) {+ super(message);+ this.name = 'AssistantIdValidationError';+ }+}++export function getAssistantErrorStatus(error: unknown): number {+ if (+ error instanceof ResourcePermissionsBusyError ||+ error instanceof ResourcePermissionsUnavailableError+ ) {+ return error.statusCode;+ }+ return error instanceof AssistantIdValidationError ? 400 : 500;+}++interface AssistantIdInput {+ req: {+ params: { id?: unknown; assistant_id?: unknown };+ body?: { assistant_id?: unknown };+ query?: { assistant_id?: unknown };+ };+ overrideAssistantId?: string;+}++function resolveAssistantId({ req, overrideAssistantId }: AssistantIdInput): string {+ let assistantId: string | undefined;+ for (const value of [+ overrideAssistantId,+ req.params.id,+ req.params.assistant_id,+ req.body?.assistant_id,+ req.query?.assistant_id,+ ]) {+ if (value === undefined) {+ continue;+ }+ if (typeof value !== 'string' || value.length === 0 || /\s/.test(value)) {+ throw new AssistantIdValidationError('Invalid Assistant ID');+ }+ if (assistantId !== undefined && value !== assistantId) {+ throw new AssistantIdValidationError('Conflicting Assistant IDs');+ }+ assistantId = value;+ }+ if (assistantId === undefined) {+ throw new AssistantIdValidationError('Assistant ID is required');+ }+ return assistantId;+}++/** Rejects invalid selectors before an assistant controller starts HTTP or streaming work. */+export const validateAssistantId: RequestHandler = (req, res, next): void => {+ try {+ resolveAssistantId({ req });+ } catch (error) {+ if (!(error instanceof AssistantIdValidationError)) {+ next(error);+ return;+ }+ res.status(400).json({ error: error.code, message: error.message });+ return;+ }+ next();+};++/** Returns the exact resource and owner scope authorized for a subsequent local mutation. */+export function createAssistantAuthorValidator({+ getAssistant,+ hasCapability,+}: AssistantAuthorDeps): (input: AssistantAuthorInput) => Promise<AssistantAuthorQuery> {+ return async (input) => {+ const { req, openai } = input;+ const assistantId = resolveAssistantId(input);+ const endpoint = req.body?.endpoint ?? req.query?.endpoint;+ const assistantsConfig = endpoint === undefined ? undefined : req.config.endpoints?.[endpoint];+ if (!assistantsConfig?.privateAssistants) {+ return { assistantId };+ }++ let canManageAssistants = false;+ try {+ canManageAssistants = await hasCapability(req.user, SystemCapabilities.MANAGE_ASSISTANTS);+ } catch {+ logger.warn('[validateAuthor] Capability check failed, denying bypass');+ }+ if (canManageAssistants) {+ return { assistantId };+ }++ const query = { assistantId, user: req.user.id };+ const assistantDoc = await getAssistant(query);+ if (assistantDoc) {+ return query;+ }+ const assistant = await openai.beta.assistants.retrieve(assistantId);+ if (req.user.id !== assistant?.metadata?.author) {+ throw new Error('Assistant is not authored by the user');+ }+ return query;+ };+}diff --git a/packages/api/src/assistants/avatar.spec.ts b/packages/api/src/assistants/avatar.spec.tsnew file mode 100644index 0000000000..7c2bcd6ff7--- /dev/null+++ b/packages/api/src/assistants/avatar.spec.ts@@ -0,0 +1,249 @@+import os from 'node:os';+import path from 'node:path';+import { promises as fs } from 'node:fs';+import { FileContext } from 'librechat-data-provider';+import { createLocalFileDeleter } from '../storage/local';+import { commitAssistantAvatar } from './avatar';++const owner = '65cfb246f7ecadb8b1e8036c';+const manager = '65cfb246f7ecadb8b1e8036b';+const oldAvatar = { filepath: `/images/${owner}/old.png`, source: 'local' };+const newAvatar = { filepath: `/images/${manager}/new.png`, source: 'local' };+const oldFile = {+ file_id: 'old-file',+ filepath: oldAvatar.filepath,+ user: owner,+ tenantId: 'tenant-a',+ source: 'local',+};++function setup() {+ const deleteFile = jest.fn().mockResolvedValue(undefined);+ const leases = new Map<string, string>();+ const deps = {+ lease: {+ acquireResourceLock: jest.fn(async ({ key, ownerId }: { key: string; ownerId: string }) => {+ if (leases.has(key)) return false;+ leases.set(key, ownerId);+ return true;+ }),+ renewResourceLock: jest.fn(+ async ({ key, ownerId }: { key: string; ownerId: string }) => leases.get(key) === ownerId,+ ),+ releaseResourceLock: jest.fn(async ({ key, ownerId }: { key: string; ownerId: string }) => {+ if (leases.get(key) !== ownerId) return false;+ leases.delete(key);+ return true;+ }),+ },+ updateAssistantAvatar: jest.fn().mockResolvedValue({ previousAvatar: oldAvatar }),+ updateProvider: jest.fn().mockResolvedValue({ id: 'asst-target', metadata: {} }),+ getFiles: jest.fn().mockResolvedValue([oldFile]),+ deleteFileByFilter: jest.fn().mockResolvedValue(oldFile),+ getStrategyFunctions: jest.fn().mockReturnValue({ deleteFile }),+ };+ const req = {+ user: { id: manager, tenantId: 'tenant-a' },+ config: { paths: { publicPath: '', uploads: '' } },+ };+ const input = {+ req,+ query: { assistantId: 'asst-target' },+ identity: { user: owner, endpoint: 'assistants' },+ uploadAvatar: jest.fn().mockResolvedValue(newAvatar),+ metadata: { author: owner },+ };+ return { deps, deleteFile, req, input };+}++describe('assistant avatar commit and cleanup', () => {+ it('deletes using the persisted file owner only after both writes succeed', async () => {+ const { deps, deleteFile, input } = setup();+ const order: string[] = [];+ deps.updateAssistantAvatar.mockImplementation(async () => {+ order.push('database');+ return { previousAvatar: oldAvatar };+ });+ deps.updateProvider.mockImplementation(async () => {+ order.push('provider');+ return { id: 'asst-target' };+ });+ deleteFile.mockImplementation(async () => {+ order.push('blob');+ });+ deps.deleteFileByFilter.mockImplementation(async () => {+ order.push('file-row');+ return oldFile;+ });++ await expect(commitAssistantAvatar(input, deps)).resolves.toEqual({ id: 'asst-target' });+ expect(order).toEqual(['database', 'provider', 'blob', 'file-row']);+ expect(deps.getFiles).toHaveBeenCalledWith(+ { filepath: oldAvatar.filepath, context: FileContext.avatar },+ null,+ null,+ 2,+ );+ expect(deleteFile).toHaveBeenCalledWith(+ expect.objectContaining({ user: { id: owner, _id: owner, tenantId: 'tenant-a' } }),+ oldFile,+ );+ expect(input.req.user.id).toBe(manager);+ expect(deps.deleteFileByFilter).toHaveBeenCalledWith({+ file_id: oldFile.file_id,+ filepath: oldFile.filepath,+ user: owner,+ });+ });++ it('removes an actual local avatar from the old owner namespace', async () => {+ const { deps, input } = setup();+ const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'assistant-cleanup-'));+ try {+ const oldPath = path.join(directory, 'images', owner, 'old.png');+ await fs.mkdir(path.dirname(oldPath), { recursive: true });+ await fs.writeFile(oldPath, 'old-avatar');+ input.req.config.paths = { publicPath: directory, uploads: path.join(directory, 'uploads') };+ const deleteRagFile = jest.fn().mockResolvedValue(undefined);+ const deleteFile = createLocalFileDeleter({+ deleteRagFile,+ logger: { warn: jest.fn(), error: jest.fn() },+ });+ deps.getStrategyFunctions.mockReturnValue({ deleteFile });+ await commitAssistantAvatar(input, deps);+ await expect(fs.stat(oldPath)).rejects.toMatchObject({ code: 'ENOENT' });+ expect(deleteRagFile).toHaveBeenCalledWith({ userId: owner, file: oldFile });+ expect(deps.deleteFileByFilter).toHaveBeenCalled();+ } finally {+ await fs.rm(directory, { recursive: true, force: true });+ }+ });++ it.each(['reject', 'missing'])(+ 'preserves old storage and skips the provider on failed persistence: %s',+ async (failure) => {+ const { deps, deleteFile, input } = setup();+ if (failure === 'reject')+ deps.updateAssistantAvatar.mockRejectedValue(new Error('identity changed'));+ else deps.updateAssistantAvatar.mockResolvedValue(null);+ await expect(commitAssistantAvatar(input, deps)).rejects.toThrow();+ expect(deps.updateProvider).not.toHaveBeenCalled();+ expect(deps.getFiles).not.toHaveBeenCalled();+ expect(deleteFile).not.toHaveBeenCalled();+ expect(deps.deleteFileByFilter).not.toHaveBeenCalled();+ },+ );++ it('does not remove the old file if the provider update fails', async () => {+ const { deps, deleteFile, input } = setup();+ deps.updateProvider.mockRejectedValue(new Error('provider unavailable'));+ await expect(commitAssistantAvatar(input, deps)).rejects.toThrow('provider unavailable');+ expect(deleteFile).not.toHaveBeenCalled();+ expect(deps.deleteFileByFilter).not.toHaveBeenCalled();+ });++ it('never treats provider metadata as authority to delete another file', async () => {+ const { deps, deleteFile, input } = setup();+ deps.updateAssistantAvatar.mockResolvedValue({});+ await commitAssistantAvatar(+ { ...input, metadata: { avatar: oldFile.filepath, avatar_source: 'local' } },+ deps,+ );+ expect(deps.getFiles).not.toHaveBeenCalled();+ expect(deleteFile).not.toHaveBeenCalled();+ });++ it.each([+ null,+ [],+ [oldFile, oldFile],+ [{ ...oldFile, user: undefined }],+ [{ ...oldFile, tenantId: 'tenant-b' }],+ [{ ...oldFile, source: 's3' }],+ ])('does not delete an ambiguous or mismatched stored file: %p', async (files) => {+ const { deps, deleteFile, input } = setup();+ deps.getFiles.mockResolvedValue(files);+ await commitAssistantAvatar(input, deps);+ expect(deleteFile).not.toHaveBeenCalled();+ expect(deps.deleteFileByFilter).not.toHaveBeenCalled();+ });++ it('retains the file row for retry when storage deletion fails', async () => {+ const { deps, deleteFile, input } = setup();+ deleteFile.mockRejectedValue(new Error('storage unavailable'));+ await expect(commitAssistantAvatar(input, deps)).resolves.toEqual({+ id: 'asst-target',+ metadata: {},+ });+ expect(deps.deleteFileByFilter).not.toHaveBeenCalled();+ });++ it('does not delete an unchanged avatar path', async () => {+ const { deps, deleteFile, input } = setup();+ await commitAssistantAvatar({ ...input, uploadAvatar: async () => oldAvatar }, deps);+ expect(deleteFile).not.toHaveBeenCalled();+ });+});++it('does not delete the final provider avatar when successful replacements overlap', async () => {+ const { deps, input } = setup();+ let localAvatar = oldAvatar;+ let providerAvatar = oldAvatar.filepath;+ const removed = new Set<string>();+ let finishFirst: () => void = () => undefined;+ let signalFirst: () => void = () => undefined;+ const firstStarted = new Promise<void>((resolve) => {+ signalFirst = resolve;+ });+ const firstResponse = new Promise<void>((resolve) => {+ finishFirst = resolve;+ });+ const secondAvatar = { filepath: `/images/${owner}/second.png`, source: 'local' };+ deps.updateAssistantAvatar.mockImplementation(async (_query, nextAvatar) => {+ const previousAvatar = localAvatar;+ localAvatar = nextAvatar;+ return { previousAvatar };+ });+ deps.updateProvider.mockImplementation(async (_id, { metadata }) => {+ if (metadata.avatar === newAvatar.filepath) {+ signalFirst();+ await firstResponse;+ }+ providerAvatar = metadata.avatar;+ return { id: 'asst-target', metadata };+ });+ deps.getFiles.mockImplementation(async ({ filepath }) => [{ ...oldFile, filepath }]);+ deps.getStrategyFunctions.mockReturnValue({+ deleteFile: jest.fn(async (_req, file) => {+ removed.add(file.filepath);+ }),+ });+ const first = commitAssistantAvatar(input, deps);+ await firstStarted;+ const second = commitAssistantAvatar({ ...input, uploadAvatar: async () => secondAvatar }, deps);+ setTimeout(finishFirst, 5);+ await Promise.all([first, second]);+ expect(removed.has(providerAvatar)).toBe(false);+ expect(providerAvatar).toBe(localAvatar.filepath);+});++it('does not write or delete when another request holds the avatar lease', async () => {+ const { deps, input, deleteFile } = setup();+ deps.lease.acquireResourceLock.mockResolvedValue(false);+ await expect(+ commitAssistantAvatar({ ...input, leaseOptions: { waitMs: 0 } }, deps),+ ).rejects.toMatchObject({ statusCode: 409 });+ expect(input.uploadAvatar).not.toHaveBeenCalled();+ expect(deps.updateAssistantAvatar).not.toHaveBeenCalled();+ expect(deps.updateProvider).not.toHaveBeenCalled();+ expect(deleteFile).not.toHaveBeenCalled();+});++it('does not update the provider when its avatar lease is lost', async () => {+ const { deps, input, deleteFile } = setup();+ deps.lease.renewResourceLock.mockResolvedValueOnce(true).mockResolvedValueOnce(false);+ await expect(commitAssistantAvatar(input, deps)).rejects.toMatchObject({ statusCode: 409 });+ expect(deps.updateProvider).not.toHaveBeenCalled();+ expect(deleteFile).not.toHaveBeenCalled();+ expect(deps.lease.releaseResourceLock).toHaveBeenCalledTimes(1);+});diff --git a/packages/api/src/assistants/avatar.ts b/packages/api/src/assistants/avatar.tsnew file mode 100644index 0000000000..ae076ab2ec--- /dev/null+++ b/packages/api/src/assistants/avatar.ts@@ -0,0 +1,131 @@+import { logger } from '@librechat/data-schemas';+import { FileContext } from 'librechat-data-provider';+import type { LeaseDeps, LeaseOptions } from '../admin/lease';+import { getSafeErrorMetadata } from '../utils/errors';+import { withLease } from '../admin/lease';++interface Avatar {+ filepath: string;+ source: string;+}++interface AvatarRequest {+ user: { id: string; tenantId?: string };+}++interface AvatarFile {+ file_id: string;+ filepath: string;+ user?: { toString(): string };+ tenantId?: string;+ source?: string;+ storageKey?: string;+ storageRegion?: string;+}++interface AvatarCommitInput<TRequest> {+ req: TRequest;+ query: { assistantId: string; user?: string };+ identity: { user: string; endpoint: string };+ uploadAvatar: () => Promise<Avatar>;+ metadata: Record<string, string>;+ leaseOptions?: LeaseOptions;+}++interface AvatarCommitDeps<TRequest, TAssistant> {+ lease: LeaseDeps;+ updateAssistantAvatar: (+ query: { assistantId: string; user?: string },+ avatar: Avatar,+ identity: { user: string; endpoint: string },+ ) => Promise<{ previousAvatar?: Avatar } | null>;+ updateProvider: (id: string, body: { metadata: Record<string, string> }) => Promise<TAssistant>;+ getFiles: (+ query: { filepath: string; context: FileContext },+ sort: null,+ projection: null,+ limit: number,+ ) => Promise<AvatarFile[] | null>;+ deleteFileByFilter: (query: {+ file_id: string;+ filepath: string;+ user: string;+ }) => Promise<unknown>;+ getStrategyFunctions: (source: string) => {+ deleteFile?: ((req: TRequest, file: AvatarFile) => Promise<unknown>) | null;+ };+}++/** Cleanup follows both successful writes and uses the old file's persisted storage identity. */+export async function commitAssistantAvatar<TRequest extends AvatarRequest, TAssistant>(+ { req, query, identity, uploadAvatar, metadata, leaseOptions }: AvatarCommitInput<TRequest>,+ deps: AvatarCommitDeps<TRequest, TAssistant>,+): Promise<TAssistant> {+ if (!deps.lease) {+ throw new Error('Assistant avatar lease is required');+ }+ return withLease(+ deps.lease,+ `assistant-avatar:${JSON.stringify([req.user.tenantId || null, query.assistantId])}`,+ async (fence) => {+ await fence();+ const avatar = await uploadAvatar();+ await fence();+ const updated = await deps.updateAssistantAvatar(query, avatar, identity);+ if (!updated) {+ throw new Error('Assistant avatar reference was not updated');+ }+ await fence();+ const assistant = await deps.updateProvider(query.assistantId, {+ metadata: { ...metadata, avatar: avatar.filepath, avatar_source: avatar.source },+ });+ await fence();++ const oldAvatar = updated.previousAvatar;+ if (!oldAvatar?.filepath || oldAvatar.filepath === avatar.filepath) {+ return assistant;+ }+ try {+ const files = await deps.getFiles(+ { filepath: oldAvatar.filepath, context: FileContext.avatar },+ null,+ null,+ 2,+ );+ // Provider metadata alone is not authority to delete another user's file.+ if (files?.length !== 1) {+ return assistant;+ }+ const file = files[0];+ const ownerId = file.user?.toString();+ if (+ !ownerId ||+ file.tenantId !== req.user.tenantId ||+ !file.source ||+ file.source !== oldAvatar.source+ ) {+ return assistant;+ }+ const { deleteFile } = deps.getStrategyFunctions(file.source);+ if (!deleteFile) {+ return assistant;+ }+ const ownerRequest = { ...req, user: { ...req.user, id: ownerId, _id: ownerId } };+ await fence();+ await deleteFile(ownerRequest, file);+ await deps.deleteFileByFilter({+ file_id: file.file_id,+ filepath: file.filepath,+ user: ownerId,+ });+ } catch (error) {+ logger.warn(+ '[assistantAvatar] Replaced avatar cleanup failed',+ getSafeErrorMetadata(error),+ );+ }+ return assistant;+ },+ leaseOptions,+ );+}diff --git a/packages/api/src/assistants/index.ts b/packages/api/src/assistants/index.tsindex 48cd0bba9f..bc04ed52f7 100644--- a/packages/api/src/assistants/index.ts+++ b/packages/api/src/assistants/index.ts@@ -1 +1,3 @@export * from './protection';+export * from './author';+export * from './avatar';diff --git a/packages/api/src/images/authorization.spec.ts b/packages/api/src/images/authorization.spec.tsindex c67aeb086d..f141f84dfb 100644--- a/packages/api/src/images/authorization.spec.ts+++ b/packages/api/src/images/authorization.spec.ts@@ -449,10 +449,48 @@ describe('createImageAuthorizationMiddleware', () => {`${assistantPath}?manual=true`,],},- { _id: 1, assistant_id: 1, endpoint: 1 },+ { _id: 1, assistant_id: 1, endpoint: 1, user: 1 },);});+ it.each([+ { user: VIEWER_ID, tenantId: 'tenant-a', allowed: true },+ { user: OWNER_ID, tenantId: 'tenant-a', allowed: false },+ { user: VIEWER_ID, tenantId: 'tenant-b', allowed: false },+ ])(+ 'checks private assistant ownership and tenant before granting image access: %p',+ async ({ user, tenantId, allowed }) => {+ (deps.getAssistant as jest.Mock).mockResolvedValue({+ _id: '65cfb246f7ecadb8b1e8036e',+ assistant_id: 'asst_private',+ endpoint: 'assistants',+ user,+ });+ (deps.getUserById as jest.Mock)+ .mockResolvedValueOnce({ tenantId: 'tenant-a' })+ .mockResolvedValueOnce({ tenantId });+ const middleware = createImageAuthorizationMiddleware(+ { assistantEndpoints: [{ endpoint: 'assistants', privateAssistants: true }] },+ deps,+ );+ await middleware(+ createRequest(+ `/images/${OWNER_ID}/assistant-avatar.png`,+ `refreshToken=${signUser(VIEWER_ID)}`,+ ),+ response,+ next,+ );+ if (allowed) {+ expect(next).toHaveBeenCalledTimes(1);+ expect(deps.getUserPrincipals).not.toHaveBeenCalled();+ } else {+ expect(next).not.toHaveBeenCalled();+ expect(response.status).toHaveBeenCalledWith(403);+ }+ },+ );+it('requires authentication for an otherwise shared assistant avatar', async () => {(deps.getAssistant as jest.Mock).mockResolvedValue({_id: '65cfb246f7ecadb8b1e8036e',diff --git a/packages/api/src/images/authorization.ts b/packages/api/src/images/authorization.tsindex f54f19287f..a19305c082 100644--- a/packages/api/src/images/authorization.ts+++ b/packages/api/src/images/authorization.ts@@ -54,6 +54,7 @@ type ImagePath = {type AssistantImageRecord = Pick<IAssistant, '_id' | 'assistant_id'> & {endpoint?: string;+ user?: IAssistant['user'];};type ResolvedImageConfig = {@@ -371,7 +372,7 @@ async function canViewAssistantAvatar(): Promise<boolean> {const assistant = await deps.getAssistant({ avatarFilepath: getStoredPathCandidates(imagePath) },- { _id: 1, assistant_id: 1, endpoint: 1 },+ { _id: 1, assistant_id: 1, endpoint: 1, user: 1 },);if (!assistant) {return false;@@ -383,7 +384,7 @@ async function canViewAssistantAvatar(if (!viewer || viewer.tenantId !== owner.tenantId) {return false;}- if (isSharedAssistant(assistant, configs)) {+ if (assistant.user?.toString() === viewerId || isSharedAssistant(assistant, configs)) {return true;}const principals = await loadPrincipals(viewerId, viewer, deps);diff --git a/packages/data-schemas/src/methods/assistant.avatar.spec.ts b/packages/data-schemas/src/methods/assistant.avatar.spec.tsnew file mode 100644index 0000000000..1ddf7193ac--- /dev/null+++ b/packages/data-schemas/src/methods/assistant.avatar.spec.ts@@ -0,0 +1,824 @@+import mongoose from 'mongoose';+import { createHash } from 'node:crypto';+import { MongoMemoryServer } from 'mongodb-memory-server';+import type { IAssistant } from '~/types';+import { runAsSystem, tenantStorage, SYSTEM_TENANT_ID } from '~/config/tenantContext';+import { applyTenantIsolation } from '~/models/plugins/tenantIsolation';+import { createAssistantMethods } from './assistant';+import assistantSchema from '~/schema/assistant';++const schema = assistantSchema.clone();+applyTenantIsolation(schema);+const Assistant = mongoose.model<IAssistant>('Assistant', schema);+const methods = createAssistantMethods(mongoose);+const ownerId = new mongoose.Types.ObjectId();+const attackerId = new mongoose.Types.ObjectId();+const originalAvatar = { filepath: '/images/original.png', source: 'local' };+const avatar = { filepath: '/images/replacement.png', source: 'local' };+let mongoServer: MongoMemoryServer;++const updateAvatar = (query: Parameters<typeof methods.updateAssistantAvatar>[0]) =>+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar(query, avatar),+ );++const readAssistant = (assistantId = 'victim-assistant') =>+ runAsSystem(async () => Assistant.findOne({ assistant_id: assistantId }).lean<IAssistant>());++const referenceId = (tenantId: string | null, assistantId: string) =>+ new mongoose.Types.ObjectId(+ createHash('sha256')+ .update(JSON.stringify([tenantId, assistantId]))+ .digest('hex')+ .slice(0, 24),+ );++function synchronizeAbsentReads(assistantId: string, count: number) {+ const findOne = Assistant.collection.findOne.bind(Assistant.collection);+ let release!: () => void;+ const allRead = new Promise<void>((resolve) => {+ release = resolve;+ });+ let arrived = 0;+ return jest.spyOn(Assistant.collection, 'findOne').mockImplementation(async (...args) => {+ const result = await findOne(...args);+ if (args[0].assistant_id === assistantId && !result) {+ if (++arrived === count) {+ release();+ }+ await allRead;+ }+ return result;+ });+}++beforeAll(async () => {+ mongoServer = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });+ await mongoose.connect(mongoServer.getUri());+ await Assistant.init();+});++beforeEach(async () => {+ await runAsSystem(async () => {+ await Assistant.deleteMany({});+ await Assistant.create([+ {+ assistant_id: 'victim-assistant',+ user: ownerId,+ endpoint: 'openAI',+ avatar: originalAvatar,+ tenantId: 'tenant-a',+ },+ {+ assistant_id: 'attacker-assistant',+ user: attackerId,+ endpoint: 'azureOpenAI',+ avatar: originalAvatar,+ tenantId: 'tenant-a',+ },+ ]);+ });+});++afterEach(() => {+ jest.restoreAllMocks();+});++afterAll(async () => {+ await mongoose.disconnect();+ mongoose.deleteModel('Assistant');+ await mongoServer?.stop();+});++describe('updateAssistantAvatar', () => {+ it("cannot update another user's assistant or claim its ownership", async () => {+ const result = await updateAvatar({+ assistantId: 'victim-assistant',+ user: attackerId.toString(),+ });++ expect(result).toBeNull();+ expect(await readAssistant()).toMatchObject({+ user: ownerId,+ endpoint: 'openAI',+ avatar: originalAvatar,+ });+ expect(await readAssistant('attacker-assistant')).toMatchObject({+ user: attackerId,+ endpoint: 'azureOpenAI',+ avatar: originalAvatar,+ });+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it("updates the correct owner's avatar without changing ownership or endpoint", async () => {+ const original = await readAssistant();+ const result = await updateAvatar({+ assistantId: 'victim-assistant',+ user: ownerId.toString(),+ });++ expect(result).toMatchObject({+ assistant_id: 'victim-assistant',+ user: ownerId,+ endpoint: 'openAI',+ avatar,+ });+ expect(result?._id).toEqual(original?._id);+ expect(result?.previousAvatar).toEqual(originalAvatar);+ const stored = await readAssistant();+ expect(stored).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ expect(stored).not.toHaveProperty('previousAvatar');+ expect(await readAssistant('attacker-assistant')).toMatchObject({ avatar: originalAvatar });+ });++ it('allows a manager selector without user while preserving the original owner and endpoint', async () => {+ const result = await updateAvatar({ assistantId: 'victim-assistant' });++ expect(result).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ expect(await readAssistant()).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ });++ it('returns null for an unknown assistant without inserting a document', async () => {+ const result = await updateAvatar({+ assistantId: 'missing-assistant',+ user: ownerId.toString(),+ });++ expect(result).toBeNull();+ expect(await readAssistant('missing-assistant')).toBeNull();+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it('creates an authorized shared reference in the active tenant', async () => {+ const result = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'provider-only' }, avatar, {+ user: attackerId.toString(),+ endpoint: 'assistants',+ }),+ );++ expect(result).toMatchObject({+ assistant_id: 'provider-only',+ user: attackerId,+ endpoint: 'assistants',+ tenantId: 'tenant-a',+ avatar,+ });+ expect(result).not.toHaveProperty('previousAvatar');+ expect(await readAssistant('provider-only')).toMatchObject({ avatar });+ });++ it('converges concurrent initializations across method factories within the active tenant', async () => {+ const assistantId = 'concurrent-provider-only';+ const count = 16;+ synchronizeAbsentReads(assistantId, count);+ const insert = jest.spyOn(Assistant.collection, 'insertOne');+ const results = await Promise.all(+ Array.from({ length: count }, () => {+ const factory = createAssistantMethods(mongoose);+ return tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ factory.updateAssistantAvatar({ assistantId, user: ownerId.toString() }, avatar, {+ user: ownerId.toString(),+ endpoint: 'assistants',+ }),+ );+ }),+ );++ expect(insert).toHaveBeenCalledTimes(count);+ for (const result of results) {+ expect(result).toMatchObject({+ _id: referenceId('tenant-a', assistantId),+ assistant_id: assistantId,+ user: ownerId,+ endpoint: 'assistants',+ tenantId: 'tenant-a',+ avatar,+ });+ expect(result).not.toHaveProperty('previousAvatar');+ }+ expect(+ await runAsSystem(async () => Assistant.countDocuments({ assistant_id: assistantId })),+ ).toBe(1);++ const foreign = await tenantStorage.run({ tenantId: 'tenant-b' }, async () =>+ createAssistantMethods(mongoose).updateAssistantAvatar(+ { assistantId, user: attackerId.toString() },+ originalAvatar,+ { user: attackerId.toString(), endpoint: 'azureAssistants' },+ ),+ );+ expect(foreign).toMatchObject({+ _id: referenceId('tenant-b', assistantId),+ assistant_id: assistantId,+ user: attackerId,+ endpoint: 'azureAssistants',+ tenantId: 'tenant-b',+ avatar: originalAvatar,+ });+ expect(+ await runAsSystem(async () => Assistant.countDocuments({ assistant_id: assistantId })),+ ).toBe(2);+ expect(+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ Assistant.findOne({ assistant_id: assistantId }).lean<IAssistant>(),+ ),+ ).toMatchObject({ user: ownerId, endpoint: 'assistants', avatar, tenantId: 'tenant-a' });+ });++ it('normalizes absent, empty and system tenant contexts for concurrent initialization', async () => {+ const assistantId = 'tenantless-provider-only';+ const contexts = [undefined, '', SYSTEM_TENANT_ID];+ const count = 15;+ synchronizeAbsentReads(assistantId, count);+ const results = await Promise.all(+ Array.from({ length: count }, (_, index) => {+ const factory = createAssistantMethods(mongoose);+ return tenantStorage.run({ tenantId: contexts[index % contexts.length] }, async () =>+ factory.updateAssistantAvatar({ assistantId }, avatar, {+ user: ownerId.toString(),+ endpoint: 'assistants',+ }),+ );+ }),+ );+ for (const result of results) {+ expect(result).toMatchObject({+ _id: referenceId(null, assistantId),+ user: ownerId,+ endpoint: 'assistants',+ avatar,+ });+ expect(result?.tenantId).toBeUndefined();+ }+ expect(+ await runAsSystem(async () => Assistant.countDocuments({ assistant_id: assistantId })),+ ).toBe(1);+ });++ it('does not let concurrent owner-scoped initializations take over the winning reference', async () => {+ const assistantId = 'contested-provider-only';+ const count = 16;+ const identities = [+ { user: ownerId.toString(), endpoint: 'assistants', avatar: originalAvatar },+ { user: attackerId.toString(), endpoint: 'azureAssistants', avatar },+ ];+ synchronizeAbsentReads(assistantId, count);+ const results = await Promise.allSettled(+ Array.from({ length: count }, (_, index) => {+ const factory = createAssistantMethods(mongoose);+ const identity = identities[index % identities.length];+ return tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ factory.updateAssistantAvatar({ assistantId, user: identity.user }, identity.avatar, {+ user: identity.user,+ endpoint: identity.endpoint,+ }),+ );+ }),+ );+ const reference = await readAssistant(assistantId);+ const winner = identities.find((identity) => identity.user === reference?.user.toString());+ expect(winner).toBeDefined();+ expect(reference).toMatchObject({+ _id: referenceId('tenant-a', assistantId),+ user: new mongoose.Types.ObjectId(winner?.user),+ endpoint: winner?.endpoint,+ avatar: winner?.avatar,+ tenantId: 'tenant-a',+ });+ expect(results.filter((result) => result.status === 'fulfilled')).toHaveLength(count / 2);+ for (const [index, result] of results.entries()) {+ if (identities[index % identities.length].user === winner?.user) {+ expect(result.status).toBe('fulfilled');+ if (result.status === 'fulfilled') {+ expect(result.value?._id).toEqual(reference?._id);+ }+ } else {+ expect(result.status).toBe('rejected');+ if (result.status === 'rejected') {+ expect(result.reason).toMatchObject({+ message: 'Assistant ownership changed before the avatar update',+ });+ }+ }+ }+ expect(+ await runAsSystem(async () => Assistant.countDocuments({ assistant_id: assistantId })),+ ).toBe(1);+ });++ it.each(['assistant', 'tenant'] as const)(+ 'does not recover an unrelated %s from a deterministic id collision',+ async (mismatch) => {+ const assistantId = 'colliding-provider-only';+ const _id = referenceId('tenant-a', assistantId);+ await runAsSystem(async () =>+ Assistant.create({+ _id,+ assistant_id: mismatch === 'assistant' ? 'unrelated-assistant' : assistantId,+ user: attackerId,+ endpoint: 'azureAssistants',+ tenantId: mismatch === 'tenant' ? 'tenant-b' : 'tenant-a',+ avatar: originalAvatar,+ }),+ );+ await expect(+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId, user: ownerId.toString() }, avatar, {+ user: ownerId.toString(),+ endpoint: 'assistants',+ }),+ ),+ ).rejects.toMatchObject({ code: 11000 });+ expect(+ await runAsSystem(async () => Assistant.findById(_id).lean<IAssistant>()),+ ).toMatchObject({+ user: attackerId,+ endpoint: 'azureAssistants',+ avatar: originalAvatar,+ });+ expect(await runAsSystem(async () => Assistant.countDocuments({ _id }))).toBe(1);+ },+ );++ it('never applies insert-only identity to an existing shared assistant', async () => {+ const result = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'victim-assistant' }, avatar, {+ user: attackerId.toString(),+ endpoint: 'assistants',+ }),+ );++ expect(result).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ expect(await readAssistant()).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it('creates a provider-authorized owner-scoped reference when none exists', async () => {+ const result = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar(+ { assistantId: 'provider-only', user: ownerId.toString() },+ avatar,+ { user: ownerId.toString(), endpoint: 'assistants' },+ ),+ );++ expect(result).toMatchObject({+ assistant_id: 'provider-only',+ user: ownerId,+ endpoint: 'assistants',+ tenantId: 'tenant-a',+ avatar,+ });+ });++ it('cannot duplicate or take over an existing assistant through owner-scoped insertion', async () => {+ await expect(+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar(+ { assistantId: 'victim-assistant', user: attackerId.toString() },+ avatar,+ { user: attackerId.toString(), endpoint: 'assistants' },+ ),+ ),+ ).rejects.toThrow('Assistant ownership changed');++ expect(await readAssistant()).toMatchObject({+ user: ownerId,+ endpoint: 'openAI',+ avatar: originalAvatar,+ });+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it('inserts a tenant-local reference without modifying an overlapping foreign assistant', async () => {+ const result = await tenantStorage.run({ tenantId: 'tenant-b' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'victim-assistant' }, avatar, {+ user: attackerId.toString(),+ endpoint: 'assistants',+ }),+ );++ expect(result).toMatchObject({ user: attackerId, tenantId: 'tenant-b', avatar });+ const original = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ Assistant.findOne({ assistant_id: 'victim-assistant' }).lean<IAssistant>(),+ );+ expect(original).toMatchObject({ user: ownerId, avatar: originalAvatar });+ });++ it.each([undefined, null, ''])(+ 'backfills a missing endpoint (%p) without changing its owner',+ async (endpoint) => {+ await Assistant.updateOne(+ { assistant_id: 'victim-assistant' },+ endpoint === undefined ? { $unset: { endpoint: 1 } } : { $set: { endpoint } },+ );+ const result = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'victim-assistant' }, avatar, {+ user: attackerId.toString(),+ endpoint: 'assistants',+ }),+ );+ expect(result).toMatchObject({ user: ownerId, endpoint: 'assistants', avatar });+ },+ );++ it.each([false, true])(+ 'initializes an ownerless reference with null owner=%p',+ async (nullOwner) => {+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantDoc(+ { assistantId: 'ownerless' },+ {+ conversation_starters: ['Hello'],+ append_current_datetime: true,+ avatar: originalAvatar,+ },+ ),+ );+ if (nullOwner) {+ await Assistant.updateOne({ assistant_id: 'ownerless' }, { $set: { user: null } });+ }+ const mutate = jest.spyOn(Assistant, 'findOneAndUpdate');+ const result = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar(+ { assistantId: 'ownerless', user: ownerId.toString() },+ avatar,+ { user: ownerId.toString(), endpoint: 'assistants' },+ ),+ );+ expect(result).toMatchObject({+ user: ownerId,+ endpoint: 'assistants',+ avatar,+ conversation_starters: ['Hello'],+ append_current_datetime: true,+ });+ expect(mutate).toHaveBeenCalledTimes(1);+ expect(mutate).toHaveBeenCalledWith(+ expect.objectContaining({+ _id: result?._id,+ assistant_id: 'ownerless',+ user: null,+ endpoint: null,+ avatar: originalAvatar,+ }),+ { $set: { avatar, user: ownerId.toString(), endpoint: 'assistants' } },+ { new: true },+ );+ expect(+ await runAsSystem(async () => Assistant.countDocuments({ assistant_id: 'ownerless' })),+ ).toBe(1);+ },+ );++ it('keeps an ownerless reference unchanged for an owner-scoped request without insert identity', async () => {+ await Assistant.updateOne({ assistant_id: 'victim-assistant' }, { $unset: { user: 1 } });+ const mutate = jest.spyOn(Assistant, 'findOneAndUpdate');+ expect(+ await updateAvatar({ assistantId: 'victim-assistant', user: ownerId.toString() }),+ ).toBeNull();+ expect(mutate).not.toHaveBeenCalled();+ const reference = await readAssistant();+ expect(reference?.user).toBeUndefined();+ expect(reference).toMatchObject({ endpoint: 'openAI', avatar: originalAvatar });+ });++ it('updates an incomplete shared reference without claiming identity when insert data is omitted', async () => {+ await Assistant.updateOne(+ { assistant_id: 'victim-assistant' },+ { $unset: { user: 1, endpoint: 1 } },+ );+ const result = await updateAvatar({ assistantId: 'victim-assistant' });+ expect(result).toMatchObject({ avatar, previousAvatar: originalAvatar });+ expect(result?.user).toBeUndefined();+ expect(result?.endpoint).toBeUndefined();+ expect(await readAssistant()).toMatchObject({ avatar });+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it.each([undefined, null])(+ 'updates a missing avatar (%p) without a previous file',+ async (value) => {+ await Assistant.updateOne(+ { assistant_id: 'victim-assistant' },+ value === undefined ? { $unset: { avatar: 1 } } : { $set: { avatar: value } },+ );+ const result = await updateAvatar({ assistantId: 'victim-assistant' });+ expect(result).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ expect(result?.previousAvatar).toBe(value);+ expect(await readAssistant()).not.toHaveProperty('previousAvatar');+ },+ );++ it('does not return a cleanup receipt when the requested avatar already matches', async () => {+ await updateAvatar({ assistantId: 'victim-assistant' });+ const mutate = jest.spyOn(Assistant, 'findOneAndUpdate');+ const result = await updateAvatar({ assistantId: 'victim-assistant' });+ expect(result).toMatchObject({ avatar });+ expect(result).not.toHaveProperty('previousAvatar');+ expect(mutate).not.toHaveBeenCalled();+ });++ it('uses one guarded write for a complete existing reference', async () => {+ const mutate = jest.spyOn(Assistant, 'findOneAndUpdate');+ const result = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar(+ { assistantId: 'victim-assistant', user: ownerId.toString() },+ avatar,+ { user: ownerId.toString(), endpoint: 'assistants' },+ ),+ );+ expect(result).toMatchObject({ user: ownerId, endpoint: 'openAI', avatar });+ expect(mutate).toHaveBeenCalledTimes(1);+ });++ it.each([+ { field: 'user', missingUser: false },+ { field: 'endpoint', missingUser: false },+ { field: 'user', missingUser: true },+ { field: 'endpoint', missingUser: true },+ ])(+ 'rejects a concurrent $field assignment without changing the avatar (missing user: $missingUser)',+ async ({ field, missingUser }) => {+ await Assistant.updateOne(+ { assistant_id: 'victim-assistant' },+ { $unset: { endpoint: 1, ...(missingUser ? { user: 1 } : {}) } },+ );+ const original = Assistant.collection.findOne.bind(Assistant.collection);+ let raced = false;+ jest.spyOn(Assistant.collection, 'findOne').mockImplementation(async (...args) => {+ const result = await original(...args);+ if (!raced && result) {+ raced = true;+ await Assistant.updateOne(+ { assistant_id: 'victim-assistant' },+ {+ $set: field === 'user' ? { user: attackerId } : { endpoint: 'azureAssistants' },+ },+ );+ }+ return result;+ });+ await expect(+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar(+ { assistantId: 'victim-assistant', user: ownerId.toString() },+ avatar,+ { user: ownerId.toString(), endpoint: 'assistants' },+ ),+ ),+ ).rejects.toThrow('Assistant identity changed');+ const doc = await readAssistant();+ expect(raced).toBe(true);+ expect(doc).toMatchObject({+ ...(field === 'user' ? { user: attackerId } : { endpoint: 'azureAssistants' }),+ avatar: originalAvatar,+ });+ expect(+ await runAsSystem(async () =>+ Assistant.countDocuments({ assistant_id: 'victim-assistant' }),+ ),+ ).toBe(1);+ },+ );++ it('rejects a stale avatar snapshot without overwriting the concurrent avatar', async () => {+ const concurrentAvatar = { filepath: '/images/concurrent.png', source: 'local' };+ const findOne = Assistant.collection.findOne.bind(Assistant.collection);+ let raced = false;+ jest.spyOn(Assistant.collection, 'findOne').mockImplementation(async (...args) => {+ const result = await findOne(...args);+ if (!raced && result) {+ raced = true;+ await Assistant.updateOne(+ { assistant_id: 'victim-assistant' },+ { $set: { avatar: concurrentAvatar } },+ );+ }+ return result;+ });+ await expect(updateAvatar({ assistantId: 'victim-assistant' })).rejects.toThrow(+ 'Assistant identity changed',+ );+ expect(raced).toBe(true);+ expect(await readAssistant()).toMatchObject({+ user: ownerId,+ endpoint: 'openAI',+ avatar: concurrentAvatar,+ });+ expect(+ await runAsSystem(async () => Assistant.countDocuments({ assistant_id: 'victim-assistant' })),+ ).toBe(1);+ });++ it('propagates unexpected reference read failures without writing an avatar', async () => {+ const failure = new Error('reference read failed');+ jest.spyOn(Assistant.collection, 'findOne').mockRejectedValueOnce(failure);+ const mutate = jest.spyOn(Assistant, 'findOneAndUpdate');+ const create = jest.spyOn(Assistant, 'create');+ await expect(updateAvatar({ assistantId: 'victim-assistant' })).rejects.toBe(failure);+ expect(mutate).not.toHaveBeenCalled();+ expect(create).not.toHaveBeenCalled();+ expect(await readAssistant()).toMatchObject({ avatar: originalAvatar });+ });++ it('propagates unexpected creation failures without reloading or inserting a reference', async () => {+ const failure = new Error('reference insert failed');+ jest.spyOn(Assistant.collection, 'insertOne').mockRejectedValueOnce(failure);+ const read = jest.spyOn(Assistant, 'findOne');+ await expect(+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'provider-only' }, avatar, {+ user: ownerId.toString(),+ endpoint: 'assistants',+ }),+ ),+ ).rejects.toBe(failure);+ expect(read).toHaveBeenCalledTimes(1);+ expect(await readAssistant('provider-only')).toBeNull();+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it('propagates duplicate-key reload failures without inserting another reference', async () => {+ const duplicate = Object.assign(new Error('reference already exists'), { code: 11000 });+ const failure = new Error('reference reload failed');+ jest.spyOn(Assistant.collection, 'insertOne').mockRejectedValueOnce(duplicate);+ const findOne = Assistant.collection.findOne.bind(Assistant.collection);+ jest+ .spyOn(Assistant.collection, 'findOne')+ .mockImplementationOnce((...args) => findOne(...args))+ .mockRejectedValueOnce(failure);+ await expect(+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'provider-only' }, avatar, {+ user: ownerId.toString(),+ endpoint: 'assistants',+ }),+ ),+ ).rejects.toBe(failure);+ expect(await readAssistant('provider-only')).toBeNull();+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it('propagates guarded update failures without an early avatar write', async () => {+ await Assistant.updateOne({ assistant_id: 'victim-assistant' }, { $unset: { endpoint: 1 } });+ const failure = new Error('reference update failed');+ jest.spyOn(Assistant.collection, 'findOneAndUpdate').mockRejectedValueOnce(failure);+ await expect(+ tenantStorage.run({ tenantId: 'tenant-a' }, async () =>+ methods.updateAssistantAvatar({ assistantId: 'victim-assistant' }, avatar, {+ user: ownerId.toString(),+ endpoint: 'assistants',+ }),+ ),+ ).rejects.toBe(failure);+ const reference = await readAssistant();+ expect(reference).toMatchObject({ user: ownerId, avatar: originalAvatar });+ expect(reference?.endpoint).toBeUndefined();+ expect(await runAsSystem(async () => Assistant.countDocuments())).toBe(2);+ });++ it.each<{ onInsert: unknown }>([+ { onInsert: null },+ { onInsert: {} },+ { onInsert: { user: '', endpoint: 'assistants' } },+ { onInsert: { user: attackerId.toString(), endpoint: '' } },+ { onInsert: { user: { $ne: null }, endpoint: 'assistants' } },+ { onInsert: { user: attackerId.toString(), endpoint: ['assistants'] } },+ ])('rejects invalid insert identity before querying: $onInsert', async ({ onInsert }) => {+ const findOne = jest.spyOn(Assistant, 'findOne');+ const findOneAndUpdate = jest.spyOn(Assistant, 'findOneAndUpdate');+ await expect(+ // @ts-expect-error JavaScript callers can supply invalid insertion data at runtime.+ methods.updateAssistantAvatar({ assistantId: 'provider-only' }, avatar, onInsert),+ ).rejects.toThrow('Avatar insert data must identify');+ expect(findOne).not.toHaveBeenCalled();+ expect(findOneAndUpdate).not.toHaveBeenCalled();+ });++ it('requires insert identity to agree with the authorized owner scope', async () => {+ const findOne = jest.spyOn(Assistant, 'findOne');+ const findOneAndUpdate = jest.spyOn(Assistant, 'findOneAndUpdate');+ await expect(+ methods.updateAssistantAvatar(+ { assistantId: 'provider-only', user: ownerId.toString() },+ avatar,+ { user: attackerId.toString(), endpoint: 'assistants' },+ ),+ ).rejects.toThrow('Avatar insert data must identify');+ expect(findOne).not.toHaveBeenCalled();+ expect(findOneAndUpdate).not.toHaveBeenCalled();+ });++ it.each<{ query: unknown }>([+ { query: undefined },+ { query: null },+ { query: {} },+ { query: { assistantId: undefined } },+ { query: { assistantId: null } },+ { query: { assistantId: '' } },+ { query: { assistantId: ' \t\n ' } },+ { query: { assistantId: false } },+ { query: { assistantId: 42 } },+ { query: { assistantId: [] } },+ { query: { assistantId: ['victim-assistant'] } },+ { query: { assistantId: { $ne: null } } },+ { query: Object.setPrototypeOf({}, { assistantId: 'victim-assistant' }) },+ ])('rejects invalid assistant selectors before querying: $query', async ({ query }) => {+ const findOne = jest.spyOn(Assistant, 'findOne');+ const findOneAndUpdate = jest.spyOn(Assistant, 'findOneAndUpdate');++ // @ts-expect-error JavaScript callers can supply invalid selectors at runtime.+ await expect(updateAvatar(query)).rejects.toThrow('assistantId must be a nonempty string');++ expect(findOne).not.toHaveBeenCalled();+ expect(findOneAndUpdate).not.toHaveBeenCalled();+ expect(await readAssistant()).toMatchObject({ avatar: originalAvatar });+ });++ it.each([+ { user: null },+ { user: '' },+ { user: ' \t\n ' },+ { user: false },+ { user: 42 },+ { user: [] },+ { user: [ownerId.toString()] },+ { user: { $ne: null } },+ ])('rejects invalid owner selectors before querying: $user', async ({ user }) => {+ const findOne = jest.spyOn(Assistant, 'findOne');+ const findOneAndUpdate = jest.spyOn(Assistant, 'findOneAndUpdate');++ // @ts-expect-error JavaScript callers can supply invalid owner selectors at runtime.+ await expect(updateAvatar({ assistantId: 'victim-assistant', user })).rejects.toThrow(+ 'user must be a nonempty string',+ );++ expect(findOne).not.toHaveBeenCalled();+ expect(findOneAndUpdate).not.toHaveBeenCalled();+ expect(await readAssistant()).toMatchObject({ user: ownerId, avatar: originalAvatar });+ });++ it('rejects inherited owner selectors before querying', async () => {+ const findOne = jest.spyOn(Assistant, 'findOne');+ const findOneAndUpdate = jest.spyOn(Assistant, 'findOneAndUpdate');+ const query = Object.setPrototypeOf(+ { assistantId: 'victim-assistant' },+ { user: attackerId.toString() },+ );++ await expect(updateAvatar(query)).rejects.toThrow('user must be a nonempty string');++ expect(findOne).not.toHaveBeenCalled();+ expect(findOneAndUpdate).not.toHaveBeenCalled();+ expect(await readAssistant()).toMatchObject({ user: ownerId, avatar: originalAvatar });+ });++ it("cannot update another tenant's assistant when user is omitted", async () => {+ await tenantStorage.run({ tenantId: 'tenant-b' }, async () =>+ Assistant.create({+ assistant_id: 'foreign-assistant',+ user: ownerId,+ endpoint: 'azureOpenAI',+ avatar: originalAvatar,+ }),+ );++ expect(await updateAvatar({ assistantId: 'foreign-assistant' })).toBeNull();+ expect(await readAssistant('foreign-assistant')).toMatchObject({+ user: ownerId,+ endpoint: 'azureOpenAI',+ avatar: originalAvatar,+ tenantId: 'tenant-b',+ });+ });++ it('updates only the active tenant when assistant identifiers overlap', async () => {+ await tenantStorage.run({ tenantId: 'tenant-b' }, async () =>+ Assistant.create({+ assistant_id: 'victim-assistant',+ user: attackerId,+ endpoint: 'azureOpenAI',+ avatar: originalAvatar,+ }),+ );++ expect(await updateAvatar({ assistantId: 'victim-assistant' })).toMatchObject({+ user: ownerId,+ endpoint: 'openAI',+ avatar,+ tenantId: 'tenant-a',+ });+ const foreignAssistant = await tenantStorage.run({ tenantId: 'tenant-b' }, async () =>+ Assistant.findOne({ assistant_id: 'victim-assistant' }).lean<IAssistant>(),+ );+ expect(foreignAssistant).toMatchObject({+ user: attackerId,+ endpoint: 'azureOpenAI',+ avatar: originalAvatar,+ tenantId: 'tenant-b',+ });+ });+});diff --git a/packages/data-schemas/src/methods/assistant.ts b/packages/data-schemas/src/methods/assistant.tsindex 00e94ebce4..5664ec12f8 100644--- a/packages/data-schemas/src/methods/assistant.ts+++ b/packages/data-schemas/src/methods/assistant.ts@@ -1,5 +1,7 @@+import { createHash } from 'node:crypto';import type { FilterQuery, Model, ProjectionType } from 'mongoose';import type { AssistantQuery, IAssistant } from '~/types';+import { getTenantId, SYSTEM_TENANT_ID } from '~/config/tenantContext';import { buildFilter, type FieldMap } from '~/utils/criteria';import { createIndexesWithRetry } from '~/utils/retry';@@ -19,6 +21,11 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {query: AssistantQuery,updateData: Partial<IAssistant>,) => Promise<IAssistant | null>;+ updateAssistantAvatar: (+ query: { assistantId: string; user?: string },+ avatar: NonNullable<IAssistant['avatar']>,+ onInsert?: { user: string; endpoint: string },+ ) => Promise<(IAssistant & { previousAvatar?: IAssistant['avatar'] }) | null>;deleteAssistant: (query: AssistantQuery) => Promise<IAssistant | null>;deleteAssistants: (query: AssistantQuery) => Promise<number>;getAssistants: (@@ -58,6 +65,125 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {.lean<IAssistant>();}+ /** Updates avatar and absent identity atomically; unmatched references return null without insert data. */+ async function updateAssistantAvatar(+ query: { assistantId: string; user?: string },+ avatar: NonNullable<IAssistant['avatar']>,+ onInsert?: { user: string; endpoint: string },+ ): Promise<(IAssistant & { previousAvatar?: IAssistant['avatar'] }) | null> {+ if (+ typeof query?.assistantId !== 'string' ||+ query.assistantId.trim().length === 0 ||+ !Object.prototype.hasOwnProperty.call(query, 'assistantId')+ ) {+ throw new TypeError('assistantId must be a nonempty string');+ }+ if (+ query.user !== undefined &&+ (typeof query.user !== 'string' ||+ query.user.trim().length === 0 ||+ !Object.prototype.hasOwnProperty.call(query, 'user'))+ ) {+ throw new TypeError('user must be a nonempty string');+ }++ if (+ onInsert !== undefined &&+ (typeof onInsert?.user !== 'string' ||+ onInsert.user.trim().length === 0 ||+ typeof onInsert.endpoint !== 'string' ||+ onInsert.endpoint.trim().length === 0 ||+ (query.user !== undefined && query.user !== onInsert.user))+ ) {+ throw new TypeError('Avatar insert data must identify the authorized user and endpoint');+ }++ const { assistantId, user } = query;+ const insertData = onInsert && { user: onInsert.user, endpoint: onInsert.endpoint };+ let reference = await Assistant().findOne(assistantFilter({ assistantId })).lean<IAssistant>();+ if (!reference) {+ if (!insertData) {+ return null;+ }+ // The built-in unique _id index arbitrates concurrent initialization across replicas.+ const tenantId = getTenantId();+ const tenant = tenantId && tenantId !== SYSTEM_TENANT_ID ? tenantId : null;+ const _id = new mongoose.Types.ObjectId(+ createHash('sha256')+ .update(JSON.stringify([tenant, assistantId]))+ .digest('hex')+ .slice(0, 24),+ );+ try {+ const created = await Assistant().create({+ _id,+ assistant_id: assistantId,+ ...insertData,+ avatar,+ });+ return created.toObject<IAssistant>();+ } catch (error) {+ if (+ typeof error !== 'object' ||+ error == null ||+ !('code' in error) ||+ error.code !== 11000+ ) {+ throw error;+ }+ reference = await Assistant()+ .findOne({ _id, assistant_id: assistantId })+ .lean<IAssistant>();+ if (!reference) {+ throw error;+ }+ }+ }+ if (user !== undefined && reference.user?.toString() !== user) {+ if (!insertData) {+ return null;+ }+ if (reference.user != null) {+ throw new Error('Assistant ownership changed before the avatar update');+ }+ }++ const missingUser = reference.user == null;+ const missingEndpoint = reference.endpoint == null || reference.endpoint === '';+ if (+ (!insertData || (!missingUser && !missingEndpoint)) &&+ reference.avatar?.filepath === avatar.filepath &&+ reference.avatar.source === avatar.source+ ) {+ return reference;+ }++ // Avatar and backfill share one identity guard, so a lost race cannot partially mutate the row.+ const updated = await Assistant()+ .findOneAndUpdate(+ {+ _id: reference._id,+ assistant_id: assistantId,+ user: reference.user ?? null,+ endpoint: reference.endpoint ?? null,+ avatar: reference.avatar ?? null,+ },+ {+ $set: {+ avatar,+ ...(insertData && missingUser ? { user: insertData.user } : {}),+ ...(insertData && missingEndpoint ? { endpoint: insertData.endpoint } : {}),+ },+ },+ { new: true },+ )+ .lean<IAssistant>();+ if (!updated) {+ throw new Error('Assistant identity changed before the avatar update');+ }+ return Object.assign(updated, { previousAvatar: reference.avatar });+ }+/*** Retrieves an assistant document based on the provided search params.*/@@ -98,6 +224,7 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {return {updateAssistantDoc,+ updateAssistantAvatar,deleteAssistant,deleteAssistants,getAssistants,