Skip to content

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

✒️ 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.js
index 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.js
index 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.js
index 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.js
new file mode 100644
index 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.js
index 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.js
index 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.js
index 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({ vers
const 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.js
index 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.js
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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,