Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
⌛ feat: Agent Version History and Management (#7455)
matt burnettd47d827ed9d3
diff --git a/api/models/Agent.js b/api/models/Agent.jsindex 9b34eeae65..c52c364a63 100644--- a/api/models/Agent.js+++ b/api/models/Agent.js@@ -21,7 +21,19 @@ const Agent = mongoose.model('agent', agentSchema);* @throws {Error} If the agent creation fails.*/const createAgent = async (agentData) => {- return (await Agent.create(agentData)).toObject();+ const { versions, ...versionData } = agentData;+ const timestamp = new Date();+ const initialAgentData = {+ ...agentData,+ versions: [+ {+ ...versionData,+ createdAt: timestamp,+ updatedAt: timestamp,+ },+ ],+ };+ return (await Agent.create(initialAgentData)).toObject();};/**@@ -103,6 +115,8 @@ const loadAgent = async ({ req, agent_id, endpoint, model_parameters }) => {return null;}+ agent.version = agent.versions ? agent.versions.length : 0;+if (agent.author.toString() === req.user.id) {return agent;}@@ -127,18 +141,146 @@ const loadAgent = async ({ req, agent_id, endpoint, model_parameters }) => {}};+/**+ * Check if a version already exists in the versions array, excluding timestamp and author fields+ * @param {Object} updateData - The update data to compare+ * @param {Array} versions - The existing versions array+ * @returns {Object|null} - The matching version if found, null otherwise+ */+const isDuplicateVersion = (updateData, currentData, versions) => {+ if (!versions || versions.length === 0) {+ return null;+ }++ const excludeFields = [+ '_id',+ 'id',+ 'createdAt',+ 'updatedAt',+ 'author',+ 'created_at',+ 'updated_at',+ '__v',+ 'agent_ids',+ 'versions',+ ];++ const { $push, $pull, $addToSet, ...directUpdates } = updateData;++ if (Object.keys(directUpdates).length === 0) {+ return null;+ }++ const wouldBeVersion = { ...currentData, ...directUpdates };+ const lastVersion = versions[versions.length - 1];++ const allFields = new Set([...Object.keys(wouldBeVersion), ...Object.keys(lastVersion)]);++ const importantFields = Array.from(allFields).filter((field) => !excludeFields.includes(field));++ let isMatch = true;+ for (const field of importantFields) {+ if (!wouldBeVersion[field] && !lastVersion[field]) {+ continue;+ }++ if (Array.isArray(wouldBeVersion[field]) && Array.isArray(lastVersion[field])) {+ if (wouldBeVersion[field].length !== lastVersion[field].length) {+ isMatch = false;+ break;+ }++ // Special handling for projectIds (MongoDB ObjectIds)+ if (field === 'projectIds') {+ const wouldBeIds = wouldBeVersion[field].map((id) => id.toString()).sort();+ const versionIds = lastVersion[field].map((id) => id.toString()).sort();++ if (!wouldBeIds.every((id, i) => id === versionIds[i])) {+ isMatch = false;+ break;+ }+ }+ // Handle arrays of objects like tool_kwargs+ else if (typeof wouldBeVersion[field][0] === 'object' && wouldBeVersion[field][0] !== null) {+ const sortedWouldBe = [...wouldBeVersion[field]].map((item) => JSON.stringify(item)).sort();+ const sortedVersion = [...lastVersion[field]].map((item) => JSON.stringify(item)).sort();++ if (!sortedWouldBe.every((item, i) => item === sortedVersion[i])) {+ isMatch = false;+ break;+ }+ } else {+ const sortedWouldBe = [...wouldBeVersion[field]].sort();+ const sortedVersion = [...lastVersion[field]].sort();++ if (!sortedWouldBe.every((item, i) => item === sortedVersion[i])) {+ isMatch = false;+ break;+ }+ }+ } else if (field === 'model_parameters') {+ const wouldBeParams = wouldBeVersion[field] || {};+ const lastVersionParams = lastVersion[field] || {};+ if (JSON.stringify(wouldBeParams) !== JSON.stringify(lastVersionParams)) {+ isMatch = false;+ break;+ }+ } else if (wouldBeVersion[field] !== lastVersion[field]) {+ isMatch = false;+ break;+ }+ }++ return isMatch ? lastVersion : null;+};+/*** Update an agent with new data without overwriting existing* properties, or create a new agent if it doesn't exist.+ * When an agent is updated, a copy of the current state will be saved to the versions array.** @param {Object} searchParameter - The search parameters to find the agent to update.* @param {string} searchParameter.id - The ID of the agent to update.* @param {string} [searchParameter.author] - The user ID of the agent's author.* @param {Object} updateData - An object containing the properties to update.* @returns {Promise<Agent>} The updated or newly created agent document as a plain object.+ * @throws {Error} If the update would create a duplicate version*/const updateAgent = async (searchParameter, updateData) => {const options = { new: true, upsert: false };++ const currentAgent = await Agent.findOne(searchParameter);+ if (currentAgent) {+ const { __v, _id, id, versions, ...versionData } = currentAgent.toObject();+ const { $push, $pull, $addToSet, ...directUpdates } = updateData;++ if (Object.keys(directUpdates).length > 0 && versions && versions.length > 0) {+ const duplicateVersion = isDuplicateVersion(updateData, versionData, versions);+ if (duplicateVersion) {+ const error = new Error(+ 'Duplicate version: This would create a version identical to an existing one',+ );+ error.statusCode = 409;+ error.details = {+ duplicateVersion,+ versionIndex: versions.findIndex(+ (v) => JSON.stringify(duplicateVersion) === JSON.stringify(v),+ ),+ };+ throw error;+ }+ }++ updateData.$push = {+ ...($push || {}),+ versions: {+ ...versionData,+ ...directUpdates,+ updatedAt: new Date(),+ },+ };+ }+return Agent.findOneAndUpdate(searchParameter, updateData, options).lean();};@@ -358,6 +500,38 @@ const updateAgentProjects = async ({ user, agentId, projectIds, removeProjectIdsreturn await getAgent({ id: agentId });};+/**+ * Reverts an agent to a specific version in its version history.+ * @param {Object} searchParameter - The search parameters to find the agent to revert.+ * @param {string} searchParameter.id - The ID of the agent to revert.+ * @param {string} [searchParameter.author] - The user ID of the agent's author.+ * @param {number} versionIndex - The index of the version to revert to in the versions array.+ * @returns {Promise<MongoAgent>} The updated agent document after reverting.+ * @throws {Error} If the agent is not found or the specified version does not exist.+ */+const revertAgentVersion = async (searchParameter, versionIndex) => {+ const agent = await Agent.findOne(searchParameter);+ if (!agent) {+ throw new Error('Agent not found');+ }++ if (!agent.versions || !agent.versions[versionIndex]) {+ throw new Error(`Version ${versionIndex} not found`);+ }++ const revertToVersion = agent.versions[versionIndex];++ const updateData = {+ ...revertToVersion,+ };++ delete updateData._id;+ delete updateData.id;+ delete updateData.versions;++ return Agent.findOneAndUpdate(searchParameter, updateData, { new: true }).lean();+};+module.exports = {Agent,getAgent,@@ -369,4 +543,5 @@ module.exports = {updateAgentProjects,addAgentResourceFile,removeAgentResourceFiles,+ revertAgentVersion,};diff --git a/api/models/Agent.spec.js b/api/models/Agent.spec.jsindex 051cb6800f..3eb866b692 100644--- a/api/models/Agent.spec.js+++ b/api/models/Agent.spec.js@@ -1,7 +1,25 @@+const originalEnv = {+ CREDS_KEY: process.env.CREDS_KEY,+ CREDS_IV: process.env.CREDS_IV,+};++process.env.CREDS_KEY = '0123456789abcdef0123456789abcdef';+process.env.CREDS_IV = '0123456789abcdef';+const mongoose = require('mongoose');const { v4: uuidv4 } = require('uuid');const { MongoMemoryServer } = require('mongodb-memory-server');-const { Agent, addAgentResourceFile, removeAgentResourceFiles } = require('./Agent');+const {+ Agent,+ addAgentResourceFile,+ removeAgentResourceFiles,+ createAgent,+ updateAgent,+ getAgent,+ deleteAgent,+ getListAgents,+ updateAgentProjects,+} = require('./Agent');describe('Agent Resource File Operations', () => {let mongoServer;@@ -15,6 +33,8 @@ describe('Agent Resource File Operations', () => {afterAll(async () => {await mongoose.disconnect();await mongoServer.stop();+ process.env.CREDS_KEY = originalEnv.CREDS_KEY;+ process.env.CREDS_IV = originalEnv.CREDS_IV;});beforeEach(async () => {@@ -332,3 +352,537 @@ describe('Agent Resource File Operations', () => {expect(finalFileIds).toHaveLength(0);});});++describe('Agent CRUD Operations', () => {+ let mongoServer;++ beforeAll(async () => {+ mongoServer = await MongoMemoryServer.create();+ const mongoUri = mongoServer.getUri();+ await mongoose.connect(mongoUri);+ });++ afterAll(async () => {+ await mongoose.disconnect();+ await mongoServer.stop();+ });++ beforeEach(async () => {+ await Agent.deleteMany({});+ });++ test('should create and get an agent', async () => {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();++ const newAgent = await createAgent({+ id: agentId,+ name: 'Test Agent',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ description: 'Test description',+ });++ expect(newAgent).toBeDefined();+ expect(newAgent.id).toBe(agentId);+ expect(newAgent.name).toBe('Test Agent');++ const retrievedAgent = await getAgent({ id: agentId });+ expect(retrievedAgent).toBeDefined();+ expect(retrievedAgent.id).toBe(agentId);+ expect(retrievedAgent.name).toBe('Test Agent');+ expect(retrievedAgent.description).toBe('Test description');+ });++ test('should delete an agent', async () => {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();++ await createAgent({+ id: agentId,+ name: 'Agent To Delete',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ });++ const agentBeforeDelete = await getAgent({ id: agentId });+ expect(agentBeforeDelete).toBeDefined();++ await deleteAgent({ id: agentId });++ const agentAfterDelete = await getAgent({ id: agentId });+ expect(agentAfterDelete).toBeNull();+ });++ test('should list agents by author', async () => {+ const authorId = new mongoose.Types.ObjectId();+ const otherAuthorId = new mongoose.Types.ObjectId();++ const agentIds = [];+ for (let i = 0; i < 5; i++) {+ const id = `agent_${uuidv4()}`;+ agentIds.push(id);+ await createAgent({+ id,+ name: `Agent ${i}`,+ provider: 'test',+ model: 'test-model',+ author: authorId,+ });+ }++ for (let i = 0; i < 3; i++) {+ await createAgent({+ id: `other_agent_${uuidv4()}`,+ name: `Other Agent ${i}`,+ provider: 'test',+ model: 'test-model',+ author: otherAuthorId,+ });+ }++ const result = await getListAgents({ author: authorId.toString() });++ expect(result).toBeDefined();+ expect(result.data).toBeDefined();+ expect(result.data).toHaveLength(5);+ expect(result.has_more).toBe(true);++ for (const agent of result.data) {+ expect(agent.author).toBe(authorId.toString());+ }+ });++ test('should update agent projects', async () => {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();+ const projectId1 = new mongoose.Types.ObjectId();+ const projectId2 = new mongoose.Types.ObjectId();+ const projectId3 = new mongoose.Types.ObjectId();++ await createAgent({+ id: agentId,+ name: 'Project Test Agent',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ projectIds: [projectId1],+ });++ await updateAgent(+ { id: agentId },+ { $addToSet: { projectIds: { $each: [projectId2, projectId3] } } },+ );++ await updateAgent({ id: agentId }, { $pull: { projectIds: projectId1 } });++ await updateAgent({ id: agentId }, { projectIds: [projectId2, projectId3] });++ const updatedAgent = await getAgent({ id: agentId });+ expect(updatedAgent.projectIds).toHaveLength(2);+ expect(updatedAgent.projectIds.map((id) => id.toString())).toContain(projectId2.toString());+ expect(updatedAgent.projectIds.map((id) => id.toString())).toContain(projectId3.toString());+ expect(updatedAgent.projectIds.map((id) => id.toString())).not.toContain(projectId1.toString());++ await updateAgent({ id: agentId }, { projectIds: [] });++ const emptyProjectsAgent = await getAgent({ id: agentId });+ expect(emptyProjectsAgent.projectIds).toHaveLength(0);++ const nonExistentId = `agent_${uuidv4()}`;+ await expect(+ updateAgentProjects({+ id: nonExistentId,+ projectIds: [projectId1],+ }),+ ).rejects.toThrow();+ });++ test('should handle ephemeral agent loading', async () => {+ const agentId = 'ephemeral_test';+ const endpoint = 'openai';++ const originalModule = jest.requireActual('librechat-data-provider');++ const mockDataProvider = {+ ...originalModule,+ Constants: {+ ...originalModule.Constants,+ EPHEMERAL_AGENT_ID: 'ephemeral_test',+ },+ };++ jest.doMock('librechat-data-provider', () => mockDataProvider);++ const mockReq = {+ user: { id: 'user123' },+ body: {+ promptPrefix: 'This is a test instruction',+ ephemeralAgent: {+ execute_code: true,+ mcp: ['server1', 'server2'],+ },+ },+ app: {+ locals: {+ availableTools: {+ tool__server1: {},+ tool__server2: {},+ another_tool: {},+ },+ },+ },+ };++ const params = {+ req: mockReq,+ agent_id: agentId,+ endpoint,+ model_parameters: {+ model: 'gpt-4',+ temperature: 0.7,+ },+ };++ expect(agentId).toBeDefined();+ expect(endpoint).toBeDefined();++ jest.dontMock('librechat-data-provider');+ });++ test('should handle loadAgent functionality and errors', async () => {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();++ await createAgent({+ id: agentId,+ name: 'Test Load Agent',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ tools: ['tool1', 'tool2'],+ });++ const agent = await getAgent({ id: agentId });++ expect(agent).toBeDefined();+ expect(agent.id).toBe(agentId);+ expect(agent.name).toBe('Test Load Agent');+ expect(agent.tools).toEqual(expect.arrayContaining(['tool1', 'tool2']));++ const mockLoadAgent = jest.fn().mockResolvedValue(agent);+ const loadedAgent = await mockLoadAgent();+ expect(loadedAgent).toBeDefined();+ expect(loadedAgent.id).toBe(agentId);++ const nonExistentId = `agent_${uuidv4()}`;+ const nonExistentAgent = await getAgent({ id: nonExistentId });+ expect(nonExistentAgent).toBeNull();++ const mockLoadAgentError = jest.fn().mockRejectedValue(new Error('No agent found with ID'));+ await expect(mockLoadAgentError()).rejects.toThrow('No agent found with ID');+ });+});++describe('Agent Version History', () => {+ let mongoServer;++ beforeAll(async () => {+ mongoServer = await MongoMemoryServer.create();+ const mongoUri = mongoServer.getUri();+ await mongoose.connect(mongoUri);+ });++ afterAll(async () => {+ await mongoose.disconnect();+ await mongoServer.stop();+ });++ beforeEach(async () => {+ await Agent.deleteMany({});+ });++ test('should create an agent with a single entry in versions array', async () => {+ const agentId = `agent_${uuidv4()}`;+ const agent = await createAgent({+ id: agentId,+ name: 'Test Agent',+ provider: 'test',+ model: 'test-model',+ author: new mongoose.Types.ObjectId(),+ });++ expect(agent.versions).toBeDefined();+ expect(Array.isArray(agent.versions)).toBe(true);+ expect(agent.versions).toHaveLength(1);+ expect(agent.versions[0].name).toBe('Test Agent');+ expect(agent.versions[0].provider).toBe('test');+ expect(agent.versions[0].model).toBe('test-model');+ });++ test('should accumulate version history across multiple updates', async () => {+ const agentId = `agent_${uuidv4()}`;+ const author = new mongoose.Types.ObjectId();+ await createAgent({+ id: agentId,+ name: 'First Name',+ provider: 'test',+ model: 'test-model',+ author,+ description: 'First description',+ });++ await updateAgent({ id: agentId }, { name: 'Second Name', description: 'Second description' });+ await updateAgent({ id: agentId }, { name: 'Third Name', model: 'new-model' });+ const finalAgent = await updateAgent({ id: agentId }, { description: 'Final description' });++ expect(finalAgent.versions).toBeDefined();+ expect(Array.isArray(finalAgent.versions)).toBe(true);+ expect(finalAgent.versions).toHaveLength(4);++ expect(finalAgent.versions[0].name).toBe('First Name');+ expect(finalAgent.versions[0].description).toBe('First description');+ expect(finalAgent.versions[0].model).toBe('test-model');++ expect(finalAgent.versions[1].name).toBe('Second Name');+ expect(finalAgent.versions[1].description).toBe('Second description');+ expect(finalAgent.versions[1].model).toBe('test-model');++ expect(finalAgent.versions[2].name).toBe('Third Name');+ expect(finalAgent.versions[2].description).toBe('Second description');+ expect(finalAgent.versions[2].model).toBe('new-model');++ expect(finalAgent.versions[3].name).toBe('Third Name');+ expect(finalAgent.versions[3].description).toBe('Final description');+ expect(finalAgent.versions[3].model).toBe('new-model');++ expect(finalAgent.name).toBe('Third Name');+ expect(finalAgent.description).toBe('Final description');+ expect(finalAgent.model).toBe('new-model');+ });++ test('should not include metadata fields in version history', async () => {+ const agentId = `agent_${uuidv4()}`;+ await createAgent({+ id: agentId,+ name: 'Test Agent',+ provider: 'test',+ model: 'test-model',+ author: new mongoose.Types.ObjectId(),+ });++ const updatedAgent = await updateAgent({ id: agentId }, { description: 'New description' });++ expect(updatedAgent.versions).toHaveLength(2);+ expect(updatedAgent.versions[0]._id).toBeUndefined();+ expect(updatedAgent.versions[0].__v).toBeUndefined();+ expect(updatedAgent.versions[0].name).toBe('Test Agent');+ expect(updatedAgent.versions[0].author).toBeDefined();++ expect(updatedAgent.versions[1]._id).toBeUndefined();+ expect(updatedAgent.versions[1].__v).toBeUndefined();+ });++ test('should not recursively include previous versions', async () => {+ const agentId = `agent_${uuidv4()}`;+ await createAgent({+ id: agentId,+ name: 'Test Agent',+ provider: 'test',+ model: 'test-model',+ author: new mongoose.Types.ObjectId(),+ });++ await updateAgent({ id: agentId }, { name: 'Updated Name 1' });+ await updateAgent({ id: agentId }, { name: 'Updated Name 2' });+ const finalAgent = await updateAgent({ id: agentId }, { name: 'Updated Name 3' });++ expect(finalAgent.versions).toHaveLength(4);++ finalAgent.versions.forEach((version) => {+ expect(version.versions).toBeUndefined();+ });+ });++ test('should handle MongoDB operators and field updates correctly', async () => {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();+ const projectId = new mongoose.Types.ObjectId();++ await createAgent({+ id: agentId,+ name: 'MongoDB Operator Test',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ tools: ['tool1'],+ });++ await updateAgent(+ { id: agentId },+ {+ description: 'Updated description',+ $push: { tools: 'tool2' },+ $addToSet: { projectIds: projectId },+ },+ );++ const firstUpdate = await getAgent({ id: agentId });+ expect(firstUpdate.description).toBe('Updated description');+ expect(firstUpdate.tools).toContain('tool1');+ expect(firstUpdate.tools).toContain('tool2');+ expect(firstUpdate.projectIds.map((id) => id.toString())).toContain(projectId.toString());+ expect(firstUpdate.versions).toHaveLength(2);++ await updateAgent(+ { id: agentId },+ {+ tools: ['tool2', 'tool3'],+ },+ );++ const secondUpdate = await getAgent({ id: agentId });+ expect(secondUpdate.tools).toHaveLength(2);+ expect(secondUpdate.tools).toContain('tool2');+ expect(secondUpdate.tools).toContain('tool3');+ expect(secondUpdate.tools).not.toContain('tool1');+ expect(secondUpdate.versions).toHaveLength(3);++ await updateAgent(+ { id: agentId },+ {+ $push: { tools: 'tool3' },+ },+ );++ const thirdUpdate = await getAgent({ id: agentId });+ const toolCount = thirdUpdate.tools.filter((t) => t === 'tool3').length;+ expect(toolCount).toBe(2);+ expect(thirdUpdate.versions).toHaveLength(4);+ });++ test('should handle parameter objects correctly', async () => {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();++ await createAgent({+ id: agentId,+ name: 'Parameters Test',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ model_parameters: { temperature: 0.7 },+ });++ const updatedAgent = await updateAgent(+ { id: agentId },+ { model_parameters: { temperature: 0.8 } },+ );++ expect(updatedAgent.versions).toHaveLength(2);+ expect(updatedAgent.model_parameters.temperature).toBe(0.8);++ await updateAgent(+ { id: agentId },+ {+ model_parameters: {+ temperature: 0.8,+ max_tokens: 1000,+ },+ },+ );++ const complexAgent = await getAgent({ id: agentId });+ expect(complexAgent.versions).toHaveLength(3);+ expect(complexAgent.model_parameters.temperature).toBe(0.8);+ expect(complexAgent.model_parameters.max_tokens).toBe(1000);++ await updateAgent({ id: agentId }, { model_parameters: {} });++ const emptyParamsAgent = await getAgent({ id: agentId });+ expect(emptyParamsAgent.versions).toHaveLength(4);+ expect(emptyParamsAgent.model_parameters).toEqual({});+ });++ test('should detect duplicate versions and reject updates', async () => {+ const originalConsoleError = console.error;+ console.error = jest.fn();++ try {+ const agentId = `agent_${uuidv4()}`;+ const authorId = new mongoose.Types.ObjectId();+ const projectId1 = new mongoose.Types.ObjectId();+ const projectId2 = new mongoose.Types.ObjectId();++ const testCases = [+ {+ name: 'simple field update',+ initial: {+ name: 'Test Agent',+ description: 'Initial description',+ },+ update: { name: 'Updated Name' },+ duplicate: { name: 'Updated Name' },+ },+ {+ name: 'object field update',+ initial: {+ model_parameters: { temperature: 0.7 },+ },+ update: { model_parameters: { temperature: 0.8 } },+ duplicate: { model_parameters: { temperature: 0.8 } },+ },+ {+ name: 'array field update',+ initial: {+ tools: ['tool1', 'tool2'],+ },+ update: { tools: ['tool2', 'tool3'] },+ duplicate: { tools: ['tool2', 'tool3'] },+ },+ {+ name: 'projectIds update',+ initial: {+ projectIds: [projectId1],+ },+ update: { projectIds: [projectId1, projectId2] },+ duplicate: { projectIds: [projectId2, projectId1] },+ },+ ];++ for (const testCase of testCases) {+ const testAgentId = `agent_${uuidv4()}`;++ await createAgent({+ id: testAgentId,+ provider: 'test',+ model: 'test-model',+ author: authorId,+ ...testCase.initial,+ });++ await updateAgent({ id: testAgentId }, testCase.update);++ let error;+ try {+ await updateAgent({ id: testAgentId }, testCase.duplicate);+ } catch (e) {+ error = e;+ }++ expect(error).toBeDefined();+ expect(error.message).toContain('Duplicate version');+ expect(error.statusCode).toBe(409);+ expect(error.details).toBeDefined();+ expect(error.details.duplicateVersion).toBeDefined();++ const agent = await getAgent({ id: testAgentId });+ expect(agent.versions).toHaveLength(2);+ }+ } finally {+ console.error = originalConsoleError;+ }+ });+});diff --git a/api/server/controllers/agents/v1.js b/api/server/controllers/agents/v1.jsindex e0f27a13fc..64f8db3c16 100644--- a/api/server/controllers/agents/v1.js+++ b/api/server/controllers/agents/v1.js@@ -23,6 +23,7 @@ const { updateAction, getActions } = require('~/models/Action');const { updateAgentProjects } = require('~/models/Agent');const { getProjectByName } = require('~/models/Project');const { deleteFileByFilter } = require('~/models/File');+const { revertAgentVersion } = require('~/models/Agent');const { logger } = require('~/config');const systemTools = {@@ -104,6 +105,8 @@ const getAgentHandler = async (req, res) => {return res.status(404).json({ error: 'Agent not found' });}+ agent.version = agent.versions ? agent.versions.length : 0;+if (agent.avatar && agent.avatar?.source === FileSources.s3) {const originalUrl = agent.avatar.filepath;agent.avatar.filepath = await refreshS3Url(agent.avatar);@@ -127,6 +130,7 @@ const getAgentHandler = async (req, res) => {author: agent.author,projectIds: agent.projectIds,isCollaborative: agent.isCollaborative,+ version: agent.version,});}return res.status(200).json(agent);@@ -187,6 +191,14 @@ const updateAgentHandler = async (req, res) => {return res.json(updatedAgent);} catch (error) {logger.error('[/Agents/:id] Error updating Agent', error);++ if (error.statusCode === 409) {+ return res.status(409).json({+ error: error.message,+ details: error.details,+ });+ }+res.status(500).json({ error: error.message });}};@@ -411,6 +423,66 @@ const uploadAgentAvatarHandler = async (req, res) => {}};+/**+ * Reverts an agent to a previous version from its version history.+ * @route PATCH /agents/:id/revert+ * @param {object} req - Express Request object+ * @param {object} req.params - Request parameters+ * @param {string} req.params.id - The ID of the agent to revert+ * @param {object} req.body - Request body+ * @param {number} req.body.version_index - The index of the version to revert to+ * @param {object} req.user - Authenticated user information+ * @param {string} req.user.id - User ID+ * @param {string} req.user.role - User role+ * @param {ServerResponse} res - Express Response object+ * @returns {Promise<Agent>} 200 - The updated agent after reverting to the specified version+ * @throws {Error} 400 - If version_index is missing+ * @throws {Error} 403 - If user doesn't have permission to modify the agent+ * @throws {Error} 404 - If agent not found+ * @throws {Error} 500 - If there's an internal server error during the reversion process+ */+const revertAgentVersionHandler = async (req, res) => {+ try {+ const { id } = req.params;+ const { version_index } = req.body;++ if (version_index === undefined) {+ return res.status(400).json({ error: 'version_index is required' });+ }++ const isAdmin = req.user.role === SystemRoles.ADMIN;+ const existingAgent = await getAgent({ id });++ if (!existingAgent) {+ return res.status(404).json({ error: 'Agent not found' });+ }++ const isAuthor = existingAgent.author.toString() === req.user.id;+ const hasEditPermission = existingAgent.isCollaborative || isAdmin || isAuthor;++ if (!hasEditPermission) {+ return res.status(403).json({+ error: 'You do not have permission to modify this non-collaborative agent',+ });+ }++ const updatedAgent = await revertAgentVersion({ id }, version_index);++ if (updatedAgent.author) {+ updatedAgent.author = updatedAgent.author.toString();+ }++ if (updatedAgent.author !== req.user.id) {+ delete updatedAgent.author;+ }++ return res.json(updatedAgent);+ } catch (error) {+ logger.error('[/agents/:id/revert] Error reverting Agent version', error);+ res.status(500).json({ error: error.message });+ }+};+module.exports = {createAgent: createAgentHandler,getAgent: getAgentHandler,@@ -419,4 +491,5 @@ module.exports = {deleteAgent: deleteAgentHandler,getListAgents: getListAgentsHandler,uploadAgentAvatar: uploadAgentAvatarHandler,+ revertAgentVersion: revertAgentVersionHandler,};diff --git a/api/server/routes/agents/v1.js b/api/server/routes/agents/v1.jsindex f79cec2cdc..657aa79414 100644--- a/api/server/routes/agents/v1.js+++ b/api/server/routes/agents/v1.js@@ -78,6 +78,15 @@ router.post('/:id/duplicate', checkAgentCreate, v1.duplicateAgent);*/router.delete('/:id', checkAgentCreate, v1.deleteAgent);+/**+ * Reverts an agent to a previous version.+ * @route POST /agents/:id/revert+ * @param {string} req.params.id - Agent identifier.+ * @param {number} req.body.version_index - Index of the version to revert to.+ * @returns {Agent} 200 - success response - application/json+ */+router.post('/:id/revert', checkGlobalAgentShare, v1.revertAgentVersion);+/*** Returns a list of agents.* @route GET /agentsdiff --git a/client/src/common/types.ts b/client/src/common/types.tsindex ab52bfb007..6837869e8e 100644--- a/client/src/common/types.ts+++ b/client/src/common/types.ts@@ -142,6 +142,7 @@ export enum Panel {builder = 'builder',actions = 'actions',model = 'model',+ version = 'version',}export type FileSetter =diff --git a/client/src/components/SidePanel/Agents/AgentFooter.tsx b/client/src/components/SidePanel/Agents/AgentFooter.tsxindex ce99e1189f..2b3aa1bcd7 100644--- a/client/src/components/SidePanel/Agents/AgentFooter.tsx+++ b/client/src/components/SidePanel/Agents/AgentFooter.tsx@@ -1,4 +1,3 @@-import React from 'react';import { useWatch, useFormContext } from 'react-hook-form';import { SystemRoles, Permissions, PermissionTypes } from 'librechat-data-provider';import type { AgentForm, AgentPanelProps } from '~/common';@@ -11,6 +10,7 @@ import DeleteButton from './DeleteButton';import { Spinner } from '~/components';import ShareAgent from './ShareAgent';import { Panel } from '~/common';+import VersionButton from './Version/VersionButton';export default function AgentFooter({activePanel,@@ -55,6 +55,7 @@ export default function AgentFooter({return (<div className="mb-1 flex w-full flex-col gap-2">{showButtons && <AdvancedButton setActivePanel={setActivePanel} />}+ {showButtons && agent_id && <VersionButton setActivePanel={setActivePanel} />}{user?.role === SystemRoles.ADMIN && showButtons && <AdminSettings />}{/* Context Button */}<div className="flex items-center justify-end gap-2">diff --git a/client/src/components/SidePanel/Agents/AgentPanel.tsx b/client/src/components/SidePanel/Agents/AgentPanel.tsxindex 1cddf15180..d891786142 100644--- a/client/src/components/SidePanel/Agents/AgentPanel.tsx+++ b/client/src/components/SidePanel/Agents/AgentPanel.tsx@@ -87,7 +87,42 @@ export default function AgentPanel({});},onError: (err) => {- const error = err as Error;+ const error = err as Error & {+ statusCode?: number;+ details?: { duplicateVersion?: any; versionIndex?: number };+ response?: { status?: number; data?: any };+ };++ const isDuplicateVersionError =+ (error.statusCode === 409 && error.details?.duplicateVersion) ||+ (error.response?.status === 409 && error.response?.data?.details?.duplicateVersion);++ if (isDuplicateVersionError) {+ let versionIndex: number | undefined = undefined;++ if (error.details?.versionIndex !== undefined) {+ versionIndex = error.details.versionIndex;+ } else if (error.response?.data?.details?.versionIndex !== undefined) {+ versionIndex = error.response.data.details.versionIndex;+ }++ if (versionIndex === undefined || versionIndex < 0) {+ showToast({+ message: localize('com_agents_update_error'),+ status: 'error',+ duration: 5000,+ });+ } else {+ showToast({+ message: localize('com_ui_agent_version_duplicate', { versionIndex: versionIndex + 1 }),+ status: 'error',+ duration: 10000,+ });+ }++ return;+ }+showToast({message: `${localize('com_agents_update_error')}${error.message ? ` ${localize('com_ui_error')}: ${error.message}` : ''diff --git a/client/src/components/SidePanel/Agents/AgentPanelSwitch.tsx b/client/src/components/SidePanel/Agents/AgentPanelSwitch.tsxindex ae2566dc56..4dc54c9b60 100644--- a/client/src/components/SidePanel/Agents/AgentPanelSwitch.tsx+++ b/client/src/components/SidePanel/Agents/AgentPanelSwitch.tsx@@ -1,11 +1,12 @@import { useState, useEffect, useMemo } from 'react';-import { EModelEndpoint } from 'librechat-data-provider';+import { EModelEndpoint, AgentCapabilities } from 'librechat-data-provider';import type { ActionsEndpoint } from '~/common';-import type { Action, TConfig, TEndpointsConfig } from 'librechat-data-provider';-import { useGetActionsQuery, useGetEndpointsQuery } from '~/data-provider';+import type { Action, TConfig, TEndpointsConfig, TAgentsEndpoint } from 'librechat-data-provider';+import { useGetActionsQuery, useGetEndpointsQuery, useCreateAgentMutation } from '~/data-provider';import { useChatContext } from '~/Providers';import ActionsPanel from './ActionsPanel';import AgentPanel from './AgentPanel';+import VersionPanel from './Version/VersionPanel';import { Panel } from '~/common';export default function AgentPanelSwitch() {@@ -15,11 +16,19 @@ export default function AgentPanelSwitch() {const [currentAgentId, setCurrentAgentId] = useState<string | undefined>(conversation?.agent_id);const { data: actions = [] } = useGetActionsQuery(conversation?.endpoint as ActionsEndpoint);const { data: endpointsConfig = {} as TEndpointsConfig } = useGetEndpointsQuery();+ const createMutation = useCreateAgentMutation();- const agentsConfig = useMemo(- () => endpointsConfig?.[EModelEndpoint.agents] ?? ({} as TConfig | null),- [endpointsConfig],- );+ const agentsConfig = useMemo<TAgentsEndpoint | null>(() => {+ const config = endpointsConfig?.[EModelEndpoint.agents] ?? null;+ if (!config) return null;++ return {+ ...(config as TConfig),+ capabilities: Array.isArray(config.capabilities)+ ? config.capabilities.map((cap) => cap as unknown as AgentCapabilities)+ : ([] as AgentCapabilities[]),+ } as TAgentsEndpoint;+ }, [endpointsConfig]);useEffect(() => {const agent_id = conversation?.agent_id ?? '';@@ -41,12 +50,23 @@ export default function AgentPanelSwitch() {setActivePanel,setCurrentAgentId,agent_id: currentAgentId,+ createMutation,};if (activePanel === Panel.actions) {return <ActionsPanel {...commonProps} />;}+ if (activePanel === Panel.version) {+ return (+ <VersionPanel+ setActivePanel={setActivePanel}+ agentsConfig={agentsConfig}+ selectedAgentId={currentAgentId}+ />+ );+ }+return (<AgentPanel {...commonProps} agentsConfig={agentsConfig} endpointsConfig={endpointsConfig} />);diff --git a/client/src/components/SidePanel/Agents/Version/VersionButton.tsx b/client/src/components/SidePanel/Agents/Version/VersionButton.tsxnew file mode 100644index 0000000000..5708bd392f--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/VersionButton.tsx@@ -0,0 +1,26 @@+import { History } from 'lucide-react';+import { Panel } from '~/common';+import { Button } from '~/components/ui';+import { useLocalize } from '~/hooks';++interface VersionButtonProps {+ setActivePanel: (panel: Panel) => void;+}++const VersionButton = ({ setActivePanel }: VersionButtonProps) => {+ const localize = useLocalize();++ return (+ <Button+ size={'sm'}+ variant={'outline'}+ className="btn btn-neutral border-token-border-light relative h-9 w-full gap-1 rounded-lg font-medium"+ onClick={() => setActivePanel(Panel.version)}+ >+ <History className="h-4 w-4 cursor-pointer" aria-hidden="true" />+ {localize('com_ui_agent_version')}+ </Button>+ );+};++export default VersionButton;diff --git a/client/src/components/SidePanel/Agents/Version/VersionContent.tsx b/client/src/components/SidePanel/Agents/Version/VersionContent.tsxnew file mode 100644index 0000000000..25b8f5bd5b--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/VersionContent.tsx@@ -0,0 +1,68 @@+import { Spinner } from '~/components/svg';+import { useLocalize } from '~/hooks';+import VersionItem from './VersionItem';+import { VersionContext } from './VersionPanel';++type VersionContentProps = {+ selectedAgentId: string;+ isLoading: boolean;+ error: unknown;+ versionContext: VersionContext;+ onRestore: (index: number) => void;+};++export default function VersionContent({+ selectedAgentId,+ isLoading,+ error,+ versionContext,+ onRestore,+}: VersionContentProps) {+ const { versions, versionIds } = versionContext;+ const localize = useLocalize();++ if (!selectedAgentId) {+ return (+ <div className="py-8 text-center text-text-secondary">+ {localize('com_ui_agent_version_no_agent')}+ </div>+ );+ }++ if (isLoading) {+ return (+ <div className="flex items-center justify-center py-8">+ <Spinner className="h-6 w-6" />+ </div>+ );+ }++ if (error) {+ return (+ <div className="py-8 text-center text-red-500">{localize('com_ui_agent_version_error')}</div>+ );+ }++ if (versionIds.length > 0) {+ return (+ <div className="flex flex-col gap-2">+ {versionIds.map(({ id, version, isActive }) => (+ <VersionItem+ key={id}+ version={version}+ index={id}+ isActive={isActive}+ versionsLength={versions.length}+ onRestore={onRestore}+ />+ ))}+ </div>+ );+ }++ return (+ <div className="py-8 text-center text-text-secondary">+ {localize('com_ui_agent_version_empty')}+ </div>+ );+}diff --git a/client/src/components/SidePanel/Agents/Version/VersionItem.tsx b/client/src/components/SidePanel/Agents/Version/VersionItem.tsxnew file mode 100644index 0000000000..c1d27cadaf--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/VersionItem.tsx@@ -0,0 +1,67 @@+import { useLocalize } from '~/hooks';+import { VersionRecord } from './VersionPanel';++type VersionItemProps = {+ version: VersionRecord;+ index: number;+ isActive: boolean;+ versionsLength: number;+ onRestore: (index: number) => void;+};++export default function VersionItem({+ version,+ index,+ isActive,+ versionsLength,+ onRestore,+}: VersionItemProps) {+ const localize = useLocalize();++ const getVersionTimestamp = (version: VersionRecord): string => {+ const timestamp = version.updatedAt || version.createdAt;++ if (timestamp) {+ try {+ const date = new Date(timestamp);+ if (isNaN(date.getTime()) || date.toString() === 'Invalid Date') {+ return localize('com_ui_agent_version_unknown_date');+ }+ return date.toLocaleString();+ } catch (error) {+ return localize('com_ui_agent_version_unknown_date');+ }+ }++ return localize('com_ui_agent_version_no_date');+ };++ return (+ <div className="rounded-md border border-border-light p-3">+ <div className="flex items-center justify-between font-medium">+ <span>+ {localize('com_ui_agent_version_title', { versionNumber: versionsLength - index })}+ </span>+ {isActive && (+ <span className="rounded-full border border-green-600 bg-green-600/20 px-2 py-0.5 text-xs font-medium text-green-700 dark:border-green-500 dark:bg-green-500/30 dark:text-green-300">+ {localize('com_ui_agent_version_active')}+ </span>+ )}+ </div>+ <div className="text-sm text-text-secondary">{getVersionTimestamp(version)}</div>+ {!isActive && (+ <button+ className="mt-2 text-sm text-blue-500 hover:text-blue-600"+ onClick={() => {+ if (window.confirm(localize('com_ui_agent_version_restore_confirm'))) {+ onRestore(index);+ }+ }}+ aria-label={localize('com_ui_agent_version_restore')}+ >+ {localize('com_ui_agent_version_restore')}+ </button>+ )}+ </div>+ );+}diff --git a/client/src/components/SidePanel/Agents/Version/VersionPanel.tsx b/client/src/components/SidePanel/Agents/Version/VersionPanel.tsxnew file mode 100644index 0000000000..9d76aba75a--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/VersionPanel.tsx@@ -0,0 +1,189 @@+import type { Agent, TAgentsEndpoint } from 'librechat-data-provider';+import { ChevronLeft } from 'lucide-react';+import { useCallback, useMemo } from 'react';+import type { AgentPanelProps } from '~/common';+import { Panel } from '~/common';+import { useGetAgentByIdQuery, useRevertAgentVersionMutation } from '~/data-provider';+import { useLocalize, useToast } from '~/hooks';+import VersionContent from './VersionContent';+import { isActiveVersion } from './isActiveVersion';++export type VersionRecord = Record<string, any>;++export type AgentState = {+ name: string | null;+ description: string | null;+ instructions: string | null;+ artifacts?: string | null;+ capabilities?: string[];+ tools?: string[];+} | null;++export type VersionWithId = {+ id: number;+ originalIndex: number;+ version: VersionRecord;+ isActive: boolean;+};++export type VersionContext = {+ versions: VersionRecord[];+ versionIds: VersionWithId[];+ currentAgent: AgentState;+ selectedAgentId: string;+ activeVersion: VersionRecord | null;+};++export interface AgentWithVersions extends Agent {+ capabilities?: string[];+ versions?: Array<VersionRecord>;+}++export type VersionPanelProps = {+ agentsConfig: TAgentsEndpoint | null;+ setActivePanel: AgentPanelProps['setActivePanel'];+ selectedAgentId?: string;+};++export default function VersionPanel({ setActivePanel, selectedAgentId = '' }: VersionPanelProps) {+ const localize = useLocalize();+ const { showToast } = useToast();+ const {+ data: agent,+ isLoading,+ error,+ refetch,+ } = useGetAgentByIdQuery(selectedAgentId, {+ enabled: !!selectedAgentId && selectedAgentId !== '',+ });++ const revertAgentVersion = useRevertAgentVersionMutation({+ onSuccess: () => {+ showToast({+ message: localize('com_ui_agent_version_restore_success'),+ status: 'success',+ });+ refetch();+ },+ onError: () => {+ showToast({+ message: localize('com_ui_agent_version_restore_error'),+ status: 'error',+ });+ },+ });++ const agentWithVersions = agent as AgentWithVersions;++ const currentAgent = useMemo(() => {+ if (!agentWithVersions) return null;+ return {+ name: agentWithVersions.name,+ description: agentWithVersions.description,+ instructions: agentWithVersions.instructions,+ artifacts: agentWithVersions.artifacts,+ capabilities: agentWithVersions.capabilities,+ tools: agentWithVersions.tools,+ };+ }, [agentWithVersions]);++ const versions = useMemo(() => {+ const versionsCopy = [...(agentWithVersions?.versions || [])];+ return versionsCopy.sort((a, b) => {+ const aTime = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;+ const bTime = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;+ return bTime - aTime;+ });+ }, [agentWithVersions?.versions]);++ const activeVersion = useMemo(() => {+ return versions.length > 0+ ? versions.find((v) => isActiveVersion(v, currentAgent, versions)) || null+ : null;+ }, [versions, currentAgent]);++ const versionIds = useMemo(() => {+ if (versions.length === 0) return [];++ const matchingVersions = versions.filter((v) => isActiveVersion(v, currentAgent, versions));++ const activeVersionId =+ matchingVersions.length > 0 ? versions.findIndex((v) => v === matchingVersions[0]) : -1;++ return versions.map((version, displayIndex) => {+ const originalIndex =+ agentWithVersions?.versions?.findIndex(+ (v) =>+ v.updatedAt === version.updatedAt &&+ v.createdAt === version.createdAt &&+ v.name === version.name,+ ) ?? displayIndex;++ return {+ id: displayIndex,+ originalIndex,+ version,+ isActive: displayIndex === activeVersionId,+ };+ });+ }, [versions, currentAgent, agentWithVersions?.versions]);++ const versionContext: VersionContext = useMemo(+ () => ({+ versions,+ versionIds,+ currentAgent,+ selectedAgentId,+ activeVersion,+ }),+ [versions, versionIds, currentAgent, selectedAgentId, activeVersion],+ );++ const handleRestore = useCallback(+ (displayIndex: number) => {+ const versionWithId = versionIds.find((v) => v.id === displayIndex);++ if (versionWithId) {+ const originalIndex = versionWithId.originalIndex;++ revertAgentVersion.mutate({+ agent_id: selectedAgentId,+ version_index: originalIndex,+ });+ }+ },+ [revertAgentVersion, selectedAgentId, versionIds],+ );++ return (+ <div className="scrollbar-gutter-stable h-full min-h-[40vh] overflow-auto pb-12 text-sm">+ <div className="version-panel relative flex flex-col items-center px-16 py-4 text-center">+ <div className="absolute left-0 top-4">+ <button+ type="button"+ className="btn btn-neutral relative"+ onClick={() => {+ setActivePanel(Panel.builder);+ }}+ >+ <div className="version-panel-content flex w-full items-center justify-center gap-2">+ <ChevronLeft />+ </div>+ </button>+ </div>+ <div className="mb-2 mt-2 text-xl font-medium">+ {localize('com_ui_agent_version_history')}+ </div>+ </div>+ <div className="flex flex-col gap-4 px-2">+ <VersionContent+ selectedAgentId={selectedAgentId}+ isLoading={isLoading}+ error={error}+ versionContext={versionContext}+ onRestore={handleRestore}+ />+ </div>+ </div>+ );+}diff --git a/client/src/components/SidePanel/Agents/Version/__tests__/VersionContent.spec.tsx b/client/src/components/SidePanel/Agents/Version/__tests__/VersionContent.spec.tsxnew file mode 100644index 0000000000..36cbf9eff5--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/__tests__/VersionContent.spec.tsx@@ -0,0 +1,142 @@+import '@testing-library/jest-dom/extend-expect';+import { render, fireEvent } from '@testing-library/react';+import VersionContent from '../VersionContent';+import { VersionContext } from '../VersionPanel';++const mockRestore = 'Restore';++jest.mock('../VersionItem', () => ({+ __esModule: true,+ default: jest.fn(({ version, isActive, onRestore, index }) => (+ <div data-testid="version-item">+ <div>{version.name}</div>+ {!isActive && (+ <button data-testid={`restore-button-${index}`} onClick={() => onRestore(index)}>+ {mockRestore}+ </button>+ )}+ </div>+ )),+}));++jest.mock('~/hooks', () => ({+ useLocalize: jest.fn().mockImplementation(() => (key) => {+ const translations = {+ com_ui_agent_version_no_agent: 'No agent selected',+ com_ui_agent_version_error: 'Error loading versions',+ com_ui_agent_version_empty: 'No versions available',+ com_ui_agent_version_restore_confirm: 'Are you sure you want to restore this version?',+ com_ui_agent_version_restore: 'Restore',+ };+ return translations[key] || key;+ }),+}));++jest.mock('~/components/svg', () => ({+ Spinner: () => <div data-testid="spinner" />,+}));++const mockVersionItem = jest.requireMock('../VersionItem').default;++describe('VersionContent', () => {+ const mockVersionIds = [+ { id: 0, version: { name: 'First' }, isActive: true, originalIndex: 2 },+ { id: 1, version: { name: 'Second' }, isActive: false, originalIndex: 1 },+ { id: 2, version: { name: 'Third' }, isActive: false, originalIndex: 0 },+ ];++ const mockContext: VersionContext = {+ versions: [{ name: 'First' }, { name: 'Second' }, { name: 'Third' }],+ versionIds: mockVersionIds,+ currentAgent: { name: 'Test Agent', description: null, instructions: null },+ selectedAgentId: 'agent-123',+ activeVersion: { name: 'First' },+ };++ const defaultProps = {+ selectedAgentId: 'agent-123',+ isLoading: false,+ error: null,+ versionContext: mockContext,+ onRestore: jest.fn(),+ };++ beforeEach(() => {+ jest.clearAllMocks();+ window.confirm = jest.fn(() => true);+ });++ test('renders different UI states correctly', () => {+ const renderTest = (props) => {+ const result = render(<VersionContent {...defaultProps} {...props} />);+ return result;+ };++ const { getByTestId, unmount: unmount1 } = renderTest({ isLoading: true });+ expect(getByTestId('spinner')).toBeInTheDocument();+ unmount1();++ const { getByText: getText1, unmount: unmount2 } = renderTest({+ error: new Error('Test error'),+ });+ expect(getText1('Error loading versions')).toBeInTheDocument();+ unmount2();++ const { getByText: getText2, unmount: unmount3 } = renderTest({ selectedAgentId: '' });+ expect(getText2('No agent selected')).toBeInTheDocument();+ unmount3();++ const emptyContext = { ...mockContext, versions: [], versionIds: [] };+ const { getByText: getText3, unmount: unmount4 } = renderTest({ versionContext: emptyContext });+ expect(getText3('No versions available')).toBeInTheDocument();+ unmount4();++ mockVersionItem.mockClear();++ const { getAllByTestId } = renderTest({});+ expect(getAllByTestId('version-item')).toHaveLength(3);+ expect(mockVersionItem).toHaveBeenCalledTimes(3);+ });++ test('restore functionality works correctly', () => {+ const onRestoreMock = jest.fn();+ const { getByTestId, queryByTestId } = render(+ <VersionContent {...defaultProps} onRestore={onRestoreMock} />,+ );++ fireEvent.click(getByTestId('restore-button-1'));+ expect(onRestoreMock).toHaveBeenCalledWith(1);++ expect(queryByTestId('restore-button-0')).not.toBeInTheDocument();+ expect(queryByTestId('restore-button-1')).toBeInTheDocument();+ expect(queryByTestId('restore-button-2')).toBeInTheDocument();+ });++ test('handles edge cases in data', () => {+ const { getAllByTestId, getByText, queryByTestId, queryByText, rerender } = render(+ <VersionContent {...defaultProps} versionContext={{ ...mockContext, versions: [] }} />,+ );+ expect(getAllByTestId('version-item')).toHaveLength(mockVersionIds.length);++ rerender(+ <VersionContent {...defaultProps} versionContext={{ ...mockContext, versionIds: [] }} />,+ );+ expect(getByText('No versions available')).toBeInTheDocument();++ rerender(+ <VersionContent+ {...defaultProps}+ selectedAgentId=""+ isLoading={true}+ error={new Error('Test')}+ />,+ );+ expect(getByText('No agent selected')).toBeInTheDocument();+ expect(queryByTestId('spinner')).not.toBeInTheDocument();+ expect(queryByText('Error loading versions')).not.toBeInTheDocument();++ rerender(<VersionContent {...defaultProps} isLoading={true} error={new Error('Test')} />);+ expect(queryByTestId('spinner')).toBeInTheDocument();+ expect(queryByText('Error loading versions')).not.toBeInTheDocument();+ });+});diff --git a/client/src/components/SidePanel/Agents/Version/__tests__/VersionItem.spec.tsx b/client/src/components/SidePanel/Agents/Version/__tests__/VersionItem.spec.tsxnew file mode 100644index 0000000000..053bf0f224--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/__tests__/VersionItem.spec.tsx@@ -0,0 +1,124 @@+import '@testing-library/jest-dom/extend-expect';+import { fireEvent, render, screen } from '@testing-library/react';+import VersionItem from '../VersionItem';+import { VersionRecord } from '../VersionPanel';++jest.mock('~/hooks', () => ({+ useLocalize: jest.fn().mockImplementation(() => (key, params) => {+ const translations = {+ com_ui_agent_version_title: params?.versionNumber+ ? `Version ${params.versionNumber}`+ : 'Version',+ com_ui_agent_version_active: 'Active Version',+ com_ui_agent_version_restore: 'Restore',+ com_ui_agent_version_restore_confirm: 'Are you sure you want to restore this version?',+ com_ui_agent_version_unknown_date: 'Unknown date',+ com_ui_agent_version_no_date: 'No date',+ };+ return translations[key] || key;+ }),+}));++describe('VersionItem', () => {+ const mockVersion: VersionRecord = {+ name: 'Test Agent',+ description: 'Test Description',+ instructions: 'Test Instructions',+ updatedAt: '2023-01-01T00:00:00Z',+ };++ const defaultProps = {+ version: mockVersion,+ index: 1,+ isActive: false,+ versionsLength: 3,+ onRestore: jest.fn(),+ };++ beforeEach(() => {+ jest.clearAllMocks();+ window.confirm = jest.fn().mockImplementation(() => true);+ });++ test('renders version number and timestamp', () => {+ render(<VersionItem {...defaultProps} />);+ expect(screen.getByText('Version 2')).toBeInTheDocument();+ const date = new Date('2023-01-01T00:00:00Z').toLocaleString();+ expect(screen.getByText(date)).toBeInTheDocument();+ });++ test('active version badge and no restore button when active', () => {+ render(<VersionItem {...defaultProps} isActive={true} />);+ expect(screen.getByText('Active Version')).toBeInTheDocument();+ expect(screen.queryByText('Restore')).not.toBeInTheDocument();+ });++ test('restore button and no active badge when not active', () => {+ render(<VersionItem {...defaultProps} isActive={false} />);+ expect(screen.queryByText('Active Version')).not.toBeInTheDocument();+ expect(screen.getByText('Restore')).toBeInTheDocument();+ });++ test('restore confirmation flow - confirmed', () => {+ render(<VersionItem {...defaultProps} />);+ fireEvent.click(screen.getByText('Restore'));+ expect(window.confirm).toHaveBeenCalledWith('Are you sure you want to restore this version?');+ expect(defaultProps.onRestore).toHaveBeenCalledWith(1);+ });++ test('restore confirmation flow - canceled', () => {+ window.confirm = jest.fn().mockImplementation(() => false);+ render(<VersionItem {...defaultProps} />);+ fireEvent.click(screen.getByText('Restore'));+ expect(window.confirm).toHaveBeenCalled();+ expect(defaultProps.onRestore).not.toHaveBeenCalled();+ });++ test('handles invalid timestamp', () => {+ render(+ <VersionItem {...defaultProps} version={{ ...mockVersion, updatedAt: 'invalid-date' }} />,+ );+ expect(screen.getByText('Unknown date')).toBeInTheDocument();+ });++ test('handles missing timestamps', () => {+ render(+ <VersionItem+ {...defaultProps}+ version={{ ...mockVersion, updatedAt: undefined, createdAt: undefined }}+ />,+ );+ expect(screen.getByText('No date')).toBeInTheDocument();+ });++ test('prefers updatedAt over createdAt when both exist', () => {+ const versionWithBothDates = {+ ...mockVersion,+ updatedAt: '2023-01-02T00:00:00Z',+ createdAt: '2023-01-01T00:00:00Z',+ };+ render(<VersionItem {...defaultProps} version={versionWithBothDates} />);+ const updatedDate = new Date('2023-01-02T00:00:00Z').toLocaleString();+ expect(screen.getByText(updatedDate)).toBeInTheDocument();+ });++ test('falls back to createdAt when updatedAt is missing', () => {+ render(+ <VersionItem+ {...defaultProps}+ version={{+ ...mockVersion,+ updatedAt: undefined,+ createdAt: '2023-01-01T00:00:00Z',+ }}+ />,+ );+ const createdDate = new Date('2023-01-01T00:00:00Z').toLocaleString();+ expect(screen.getByText(createdDate)).toBeInTheDocument();+ });++ test('handles empty version object', () => {+ render(<VersionItem {...defaultProps} version={{}} />);+ expect(screen.getByText('No date')).toBeInTheDocument();+ });+});diff --git a/client/src/components/SidePanel/Agents/Version/__tests__/VersionPanel.spec.tsx b/client/src/components/SidePanel/Agents/Version/__tests__/VersionPanel.spec.tsxnew file mode 100644index 0000000000..d9cf31eff3--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/__tests__/VersionPanel.spec.tsx@@ -0,0 +1,194 @@+import '@testing-library/jest-dom/extend-expect';+import { fireEvent, render, screen } from '@testing-library/react';+import { Panel } from '~/common/types';+import VersionContent from '../VersionContent';+import VersionPanel from '../VersionPanel';++const mockAgentData = {+ name: 'Test Agent',+ description: 'Test Description',+ instructions: 'Test Instructions',+ tools: ['tool1', 'tool2'],+ capabilities: ['capability1', 'capability2'],+ versions: [+ {+ name: 'Version 1',+ description: 'Description 1',+ instructions: 'Instructions 1',+ tools: ['tool1'],+ capabilities: ['capability1'],+ createdAt: '2023-01-01T00:00:00Z',+ updatedAt: '2023-01-01T00:00:00Z',+ },+ {+ name: 'Version 2',+ description: 'Description 2',+ instructions: 'Instructions 2',+ tools: ['tool1', 'tool2'],+ capabilities: ['capability1', 'capability2'],+ createdAt: '2023-01-02T00:00:00Z',+ updatedAt: '2023-01-02T00:00:00Z',+ },+ ],+};++jest.mock('~/data-provider', () => ({+ useGetAgentByIdQuery: jest.fn(() => ({+ data: mockAgentData,+ isLoading: false,+ error: null,+ refetch: jest.fn(),+ })),+ useRevertAgentVersionMutation: jest.fn(() => ({+ mutate: jest.fn(),+ isLoading: false,+ })),+}));++jest.mock('../VersionContent', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="version-content" />),+}));++jest.mock('~/hooks', () => ({+ useLocalize: jest.fn().mockImplementation(() => (key) => key),+ useToast: jest.fn(() => ({ showToast: jest.fn() })),+}));++describe('VersionPanel', () => {+ const mockSetActivePanel = jest.fn();+ const defaultProps = {+ agentsConfig: null,+ setActivePanel: mockSetActivePanel,+ selectedAgentId: 'agent-123',+ };+ const mockUseGetAgentByIdQuery = jest.requireMock('~/data-provider').useGetAgentByIdQuery;++ beforeEach(() => {+ jest.clearAllMocks();+ mockUseGetAgentByIdQuery.mockReturnValue({+ data: mockAgentData,+ isLoading: false,+ error: null,+ refetch: jest.fn(),+ });+ });++ test('renders panel UI and handles navigation', () => {+ render(<VersionPanel {...defaultProps} />);+ expect(screen.getByText('com_ui_agent_version_history')).toBeInTheDocument();+ expect(screen.getByTestId('version-content')).toBeInTheDocument();++ fireEvent.click(screen.getByRole('button'));+ expect(mockSetActivePanel).toHaveBeenCalledWith(Panel.builder);+ });++ test('VersionContent receives correct props', () => {+ render(<VersionPanel {...defaultProps} />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({+ selectedAgentId: 'agent-123',+ isLoading: false,+ error: null,+ versionContext: expect.objectContaining({+ currentAgent: expect.any(Object),+ versions: expect.any(Array),+ versionIds: expect.any(Array),+ }),+ }),+ expect.anything(),+ );+ });++ test('handles data state variations', () => {+ render(<VersionPanel {...defaultProps} selectedAgentId="" />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({ selectedAgentId: '' }),+ expect.anything(),+ );++ mockUseGetAgentByIdQuery.mockReturnValueOnce({+ data: null,+ isLoading: false,+ error: null,+ refetch: jest.fn(),+ });+ render(<VersionPanel {...defaultProps} />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({+ versionContext: expect.objectContaining({+ versions: [],+ versionIds: [],+ currentAgent: null,+ }),+ }),+ expect.anything(),+ );++ mockUseGetAgentByIdQuery.mockReturnValueOnce({+ data: { ...mockAgentData, versions: undefined },+ isLoading: false,+ error: null,+ refetch: jest.fn(),+ });+ render(<VersionPanel {...defaultProps} />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({+ versionContext: expect.objectContaining({ versions: [] }),+ }),+ expect.anything(),+ );++ mockUseGetAgentByIdQuery.mockReturnValueOnce({+ data: null,+ isLoading: true,+ error: null,+ refetch: jest.fn(),+ });+ render(<VersionPanel {...defaultProps} />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({ isLoading: true }),+ expect.anything(),+ );++ const testError = new Error('Test error');+ mockUseGetAgentByIdQuery.mockReturnValueOnce({+ data: null,+ isLoading: false,+ error: testError,+ refetch: jest.fn(),+ });+ render(<VersionPanel {...defaultProps} />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({ error: testError }),+ expect.anything(),+ );+ });++ test('memoizes agent data correctly', () => {+ mockUseGetAgentByIdQuery.mockReturnValueOnce({+ data: mockAgentData,+ isLoading: false,+ error: null,+ refetch: jest.fn(),+ });++ render(<VersionPanel {...defaultProps} />);+ expect(VersionContent).toHaveBeenCalledWith(+ expect.objectContaining({+ versionContext: expect.objectContaining({+ currentAgent: expect.objectContaining({+ name: 'Test Agent',+ description: 'Test Description',+ instructions: 'Test Instructions',+ }),+ versions: expect.arrayContaining([+ expect.objectContaining({ name: 'Version 2' }),+ expect.objectContaining({ name: 'Version 1' }),+ ]),+ }),+ }),+ expect.anything(),+ );+ });+});diff --git a/client/src/components/SidePanel/Agents/Version/__tests__/isActiveVersion.spec.ts b/client/src/components/SidePanel/Agents/Version/__tests__/isActiveVersion.spec.tsnew file mode 100644index 0000000000..d6ef786d9c--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/__tests__/isActiveVersion.spec.ts@@ -0,0 +1,238 @@+import { isActiveVersion } from '../isActiveVersion';+import type { AgentState, VersionRecord } from '../VersionPanel';++describe('isActiveVersion', () => {+ const createVersion = (overrides = {}): VersionRecord => ({+ name: 'Test Agent',+ description: 'Test Description',+ instructions: 'Test Instructions',+ artifacts: 'default',+ tools: ['tool1', 'tool2'],+ capabilities: ['capability1', 'capability2'],+ ...overrides,+ });++ const createAgentState = (overrides = {}): AgentState => ({+ name: 'Test Agent',+ description: 'Test Description',+ instructions: 'Test Instructions',+ artifacts: 'default',+ tools: ['tool1', 'tool2'],+ capabilities: ['capability1', 'capability2'],+ ...overrides,+ });++ test('returns true for the first version in versions array when currentAgent is null', () => {+ const versions = [+ createVersion({ name: 'First Version' }),+ createVersion({ name: 'Second Version' }),+ ];++ expect(isActiveVersion(versions[0], null, versions)).toBe(true);+ expect(isActiveVersion(versions[1], null, versions)).toBe(false);+ });++ test('returns true when all fields match exactly', () => {+ const version = createVersion();+ const currentAgent = createAgentState();+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('returns false when names do not match', () => {+ const version = createVersion();+ const currentAgent = createAgentState({ name: 'Different Name' });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('returns false when descriptions do not match', () => {+ const version = createVersion();+ const currentAgent = createAgentState({ description: 'Different Description' });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('returns false when instructions do not match', () => {+ const version = createVersion();+ const currentAgent = createAgentState({ instructions: 'Different Instructions' });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('returns false when artifacts do not match', () => {+ const version = createVersion();+ const currentAgent = createAgentState({ artifacts: 'different_artifacts' });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('matches tools regardless of order', () => {+ const version = createVersion({ tools: ['tool1', 'tool2'] });+ const currentAgent = createAgentState({ tools: ['tool2', 'tool1'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('returns false when tools arrays have different lengths', () => {+ const version = createVersion({ tools: ['tool1', 'tool2'] });+ const currentAgent = createAgentState({ tools: ['tool1', 'tool2', 'tool3'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('returns false when tools do not match', () => {+ const version = createVersion({ tools: ['tool1', 'tool2'] });+ const currentAgent = createAgentState({ tools: ['tool1', 'different'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('matches capabilities regardless of order', () => {+ const version = createVersion({ capabilities: ['capability1', 'capability2'] });+ const currentAgent = createAgentState({ capabilities: ['capability2', 'capability1'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('returns false when capabilities arrays have different lengths', () => {+ const version = createVersion({ capabilities: ['capability1', 'capability2'] });+ const currentAgent = createAgentState({+ capabilities: ['capability1', 'capability2', 'capability3'],+ });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('returns false when capabilities do not match', () => {+ const version = createVersion({ capabilities: ['capability1', 'capability2'] });+ const currentAgent = createAgentState({ capabilities: ['capability1', 'different'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ describe('edge cases', () => {+ test('handles missing tools arrays', () => {+ const version = createVersion({ tools: undefined });+ const currentAgent = createAgentState({ tools: undefined });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('handles when version has tools but agent does not', () => {+ const version = createVersion({ tools: ['tool1', 'tool2'] });+ const currentAgent = createAgentState({ tools: undefined });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles when agent has tools but version does not', () => {+ const version = createVersion({ tools: undefined });+ const currentAgent = createAgentState({ tools: ['tool1', 'tool2'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles missing capabilities arrays', () => {+ const version = createVersion({ capabilities: undefined });+ const currentAgent = createAgentState({ capabilities: undefined });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('handles when version has capabilities but agent does not', () => {+ const version = createVersion({ capabilities: ['capability1', 'capability2'] });+ const currentAgent = createAgentState({ capabilities: undefined });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles when agent has capabilities but version does not', () => {+ const version = createVersion({ capabilities: undefined });+ const currentAgent = createAgentState({ capabilities: ['capability1', 'capability2'] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles null values in fields', () => {+ const version = createVersion({ name: null });+ const currentAgent = createAgentState({ name: null });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('handles empty versions array', () => {+ const version = createVersion();+ const currentAgent = createAgentState();+ const versions = [];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles empty arrays for tools', () => {+ const version = createVersion({ tools: [] });+ const currentAgent = createAgentState({ tools: [] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('handles empty arrays for capabilities', () => {+ const version = createVersion({ capabilities: [] });+ const currentAgent = createAgentState({ capabilities: [] });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('handles missing artifacts field', () => {+ const version = createVersion({ artifacts: undefined });+ const currentAgent = createAgentState({ artifacts: undefined });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });++ test('handles when version has artifacts but agent does not', () => {+ const version = createVersion();+ const currentAgent = createAgentState({ artifacts: undefined });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles when agent has artifacts but version does not', () => {+ const version = createVersion({ artifacts: undefined });+ const currentAgent = createAgentState();+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(false);+ });++ test('handles empty string for artifacts', () => {+ const version = createVersion({ artifacts: '' });+ const currentAgent = createAgentState({ artifacts: '' });+ const versions = [version];++ expect(isActiveVersion(version, currentAgent, versions)).toBe(true);+ });+ });+});diff --git a/client/src/components/SidePanel/Agents/Version/isActiveVersion.ts b/client/src/components/SidePanel/Agents/Version/isActiveVersion.tsnew file mode 100644index 0000000000..61919953dd--- /dev/null+++ b/client/src/components/SidePanel/Agents/Version/isActiveVersion.ts@@ -0,0 +1,59 @@+import { AgentState, VersionRecord } from './VersionPanel';++export const isActiveVersion = (+ version: VersionRecord,+ currentAgent: AgentState,+ versions: VersionRecord[],+): boolean => {+ if (!versions || versions.length === 0) {+ return false;+ }++ if (!currentAgent) {+ const versionIndex = versions.findIndex(+ (v) =>+ v.name === version.name &&+ v.instructions === version.instructions &&+ v.artifacts === version.artifacts,+ );+ return versionIndex === 0;+ }++ const matchesName = version.name === currentAgent.name;+ const matchesDescription = version.description === currentAgent.description;+ const matchesInstructions = version.instructions === currentAgent.instructions;+ const matchesArtifacts = version.artifacts === currentAgent.artifacts;++ const toolsMatch = () => {+ if (!version.tools && !currentAgent.tools) return true;+ if (!version.tools || !currentAgent.tools) return false;+ if (version.tools.length !== currentAgent.tools.length) return false;++ const sortedVersionTools = [...version.tools].sort();+ const sortedCurrentTools = [...currentAgent.tools].sort();++ return sortedVersionTools.every((tool, i) => tool === sortedCurrentTools[i]);+ };++ const capabilitiesMatch = () => {+ if (!version.capabilities && !currentAgent.capabilities) return true;+ if (!version.capabilities || !currentAgent.capabilities) return false;+ if (version.capabilities.length !== currentAgent.capabilities.length) return false;++ const sortedVersionCapabilities = [...version.capabilities].sort();+ const sortedCurrentCapabilities = [...currentAgent.capabilities].sort();++ return sortedVersionCapabilities.every(+ (capability, i) => capability === sortedCurrentCapabilities[i],+ );+ };++ return (+ matchesName &&+ matchesDescription &&+ matchesInstructions &&+ matchesArtifacts &&+ toolsMatch() &&+ capabilitiesMatch()+ );+};diff --git a/client/src/components/SidePanel/Agents/__tests__/AgentFooter.spec.tsx b/client/src/components/SidePanel/Agents/__tests__/AgentFooter.spec.tsxnew file mode 100644index 0000000000..9a73f94a57--- /dev/null+++ b/client/src/components/SidePanel/Agents/__tests__/AgentFooter.spec.tsx@@ -0,0 +1,271 @@+import React from 'react';+import { render, screen } from '@testing-library/react';+import '@testing-library/jest-dom/extend-expect';+import AgentFooter from '../AgentFooter';+import { Panel } from '~/common';+import type { Agent, AgentCreateParams, TUser } from 'librechat-data-provider';+import { SystemRoles } from 'librechat-data-provider';+import * as reactHookForm from 'react-hook-form';+import * as hooks from '~/hooks';+import type { UseMutationResult } from '@tanstack/react-query';++jest.mock('react-hook-form', () => ({+ useFormContext: () => ({+ control: {},+ }),+ useWatch: () => {+ return {+ agent: {+ name: 'Test Agent',+ author: 'user-123',+ projectIds: ['project-1'],+ isCollaborative: false,+ },+ id: 'agent-123',+ };+ },+}));++const mockUser = {+ id: 'user-123',+ username: 'testuser',+ email: '[email protected]',+ name: 'Test User',+ avatar: '',+ role: 'USER',+ provider: 'local',+ emailVerified: true,+ createdAt: '2023-01-01T00:00:00.000Z',+ updatedAt: '2023-01-01T00:00:00.000Z',+} as TUser;++jest.mock('~/hooks', () => ({+ useLocalize: () => (key) => {+ const translations = {+ com_ui_save: 'Save',+ com_ui_create: 'Create',+ };+ return translations[key] || key;+ },+ useAuthContext: () => ({+ user: mockUser,+ token: 'mock-token',+ isAuthenticated: true,+ error: undefined,+ login: jest.fn(),+ logout: jest.fn(),+ setError: jest.fn(),+ roles: {},+ }),+ useHasAccess: () => true,+}));++const createBaseMutation = <T = Agent, P = any>(+ isLoading = false,+): UseMutationResult<T, Error, P> => {+ if (isLoading) {+ return {+ mutate: jest.fn(),+ mutateAsync: jest.fn().mockResolvedValue({} as T),+ isLoading: true,+ isError: false,+ isSuccess: false,+ isIdle: false as const,+ status: 'loading' as const,+ error: null,+ data: undefined,+ failureCount: 0,+ failureReason: null,+ reset: jest.fn(),+ context: undefined,+ variables: undefined,+ isPaused: false,+ };+ } else {+ return {+ mutate: jest.fn(),+ mutateAsync: jest.fn().mockResolvedValue({} as T),+ isLoading: false,+ isError: false,+ isSuccess: false,+ isIdle: true as const,+ status: 'idle' as const,+ error: null,+ data: undefined,+ failureCount: 0,+ failureReason: null,+ reset: jest.fn(),+ context: undefined,+ variables: undefined,+ isPaused: false,+ };+ }+};++jest.mock('~/data-provider', () => ({+ useUpdateAgentMutation: () => createBaseMutation<Agent, any>(),+}));++jest.mock('../Advanced/AdvancedButton', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="advanced-button" />),+}));++jest.mock('../Version/VersionButton', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="version-button" />),+}));++jest.mock('../AdminSettings', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="admin-settings" />),+}));++jest.mock('../DeleteButton', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="delete-button" />),+}));++jest.mock('../ShareAgent', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="share-agent" />),+}));++jest.mock('../DuplicateAgent', () => ({+ __esModule: true,+ default: jest.fn(() => <div data-testid="duplicate-agent" />),+}));++jest.mock('~/components', () => ({+ Spinner: () => <div data-testid="spinner" />,+}));++describe('AgentFooter', () => {+ const mockUsers = {+ regular: mockUser,+ admin: {+ ...mockUser,+ id: 'admin-123',+ username: 'admin',+ email: '[email protected]',+ name: 'Admin User',+ role: SystemRoles.ADMIN,+ } as TUser,+ different: {+ ...mockUser,+ id: 'different-user',+ username: 'different',+ email: '[email protected]',+ name: 'Different User',+ } as TUser,+ };++ const createAuthContext = (user: TUser) => ({+ user,+ token: 'mock-token',+ isAuthenticated: true,+ error: undefined,+ login: jest.fn(),+ logout: jest.fn(),+ setError: jest.fn(),+ roles: {},+ });++ const mockSetActivePanel = jest.fn();+ const mockSetCurrentAgentId = jest.fn();+ const mockCreateMutation = createBaseMutation<Agent, AgentCreateParams>();+ const mockUpdateMutation = createBaseMutation<Agent, any>();++ const defaultProps = {+ activePanel: Panel.builder,+ createMutation: mockCreateMutation,+ updateMutation: mockUpdateMutation,+ setActivePanel: mockSetActivePanel,+ setCurrentAgentId: mockSetCurrentAgentId,+ };++ beforeEach(() => {+ jest.clearAllMocks();+ });++ describe('Main Functionality', () => {+ test('renders with standard components based on default state', () => {+ render(<AgentFooter {...defaultProps} />);+ expect(screen.getByText('Save')).toBeInTheDocument();+ expect(screen.getByTestId('advanced-button')).toBeInTheDocument();+ expect(screen.getByTestId('version-button')).toBeInTheDocument();+ expect(screen.getByTestId('delete-button')).toBeInTheDocument();+ expect(screen.queryByTestId('admin-settings')).not.toBeInTheDocument();+ expect(screen.queryByTestId('share-agent')).not.toBeInTheDocument();+ expect(screen.queryByTestId('duplicate-agent')).not.toBeInTheDocument();+ expect(screen.queryByTestId('spinner')).not.toBeInTheDocument();+ });++ test('handles loading states for createMutation', () => {+ const { unmount } = render(+ <AgentFooter {...defaultProps} createMutation={createBaseMutation(true)} />,+ );+ expect(screen.getByTestId('spinner')).toBeInTheDocument();+ expect(screen.queryByText('Save')).not.toBeInTheDocument();+ expect(screen.getByRole('button')).toBeDisabled();+ expect(screen.getByRole('button')).toHaveAttribute('aria-busy', 'true');+ unmount();+ });++ test('handles loading states for updateMutation', () => {+ render(<AgentFooter {...defaultProps} updateMutation={createBaseMutation(true)} />);+ expect(screen.getByTestId('spinner')).toBeInTheDocument();+ expect(screen.queryByText('Save')).not.toBeInTheDocument();+ });+ });++ describe('Conditional Rendering', () => {+ test('adjusts UI based on activePanel state', () => {+ render(<AgentFooter {...defaultProps} activePanel={Panel.advanced} />);+ expect(screen.queryByTestId('advanced-button')).not.toBeInTheDocument();+ expect(screen.queryByTestId('version-button')).not.toBeInTheDocument();+ });++ test('adjusts UI based on agent ID existence', () => {+ jest.spyOn(reactHookForm, 'useWatch').mockImplementation(() => ({+ agent: { name: 'Test Agent', author: 'user-123' },+ id: undefined,+ }));++ render(<AgentFooter {...defaultProps} />);+ expect(screen.getByText('Save')).toBeInTheDocument();+ expect(screen.getByTestId('version-button')).toBeInTheDocument();+ });++ test('adjusts UI based on user role', () => {+ jest.spyOn(hooks, 'useAuthContext').mockReturnValue(createAuthContext(mockUsers.admin));+ render(<AgentFooter {...defaultProps} />);+ expect(screen.queryByTestId('admin-settings')).not.toBeInTheDocument();+ expect(screen.queryByTestId('share-agent')).not.toBeInTheDocument();++ jest.clearAllMocks();+ jest.spyOn(hooks, 'useAuthContext').mockReturnValue(createAuthContext(mockUsers.different));+ render(<AgentFooter {...defaultProps} />);+ expect(screen.queryByTestId('share-agent')).not.toBeInTheDocument();+ expect(screen.queryByTestId('duplicate-agent')).not.toBeInTheDocument();+ });++ test('adjusts UI based on permissions', () => {+ jest.spyOn(hooks, 'useHasAccess').mockReturnValue(false);+ render(<AgentFooter {...defaultProps} />);+ expect(screen.queryByTestId('share-agent')).not.toBeInTheDocument();+ });+ });++ describe('Edge Cases', () => {+ test('handles null agent data', () => {+ jest.spyOn(reactHookForm, 'useWatch').mockImplementation(() => ({+ agent: null,+ id: 'agent-123',+ }));++ render(<AgentFooter {...defaultProps} />);+ expect(screen.getByText('Save')).toBeInTheDocument();+ });+ });+});diff --git a/client/src/data-provider/Agents/mutations.ts b/client/src/data-provider/Agents/mutations.tsindex 04f40cd3dd..24af4ee898 100644--- a/client/src/data-provider/Agents/mutations.ts+++ b/client/src/data-provider/Agents/mutations.ts@@ -43,7 +43,11 @@ export const useCreateAgentMutation = (*/export const useUpdateAgentMutation = (options?: t.UpdateAgentMutationOptions,-): UseMutationResult<t.Agent, Error, { agent_id: string; data: t.AgentUpdateParams }> => {+): UseMutationResult<+ t.Agent,+ t.DuplicateVersionError,+ { agent_id: string; data: t.AgentUpdateParams }+> => {const queryClient = useQueryClient();return useMutation(({ agent_id, data }: { agent_id: string; data: t.AgentUpdateParams }) => {@@ -54,7 +58,10 @@ export const useUpdateAgentMutation = (},{onMutate: (variables) => options?.onMutate?.(variables),- onError: (error, variables, context) => options?.onError?.(error, variables, context),+ onError: (error, variables, context) => {+ const typedError = error as t.DuplicateVersionError;+ return options?.onError?.(typedError, variables, context);+ },onSuccess: (updatedAgent, variables, context) => {const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents,@@ -170,7 +177,6 @@ export const useUploadAgentAvatarMutation = (unknown // context> => {return useMutation([MutationKeys.agentAvatarUpload], {- // eslint-disable-next-line @typescript-eslint/no-unused-varsmutationFn: ({ postCreation, ...variables }: t.AgentAvatarVariables) =>dataService.uploadAgentAvatar(variables),...(options || {}),@@ -300,3 +306,46 @@ export const useDeleteAgentAction = (},});};++/**+ * Hook for reverting an agent to a previous version+ */+export const useRevertAgentVersionMutation = (+ options?: t.RevertAgentVersionOptions,+): UseMutationResult<t.Agent, Error, { agent_id: string; version_index: number }> => {+ const queryClient = useQueryClient();+ return useMutation(+ ({ agent_id, version_index }: { agent_id: string; version_index: number }) => {+ return dataService.revertAgentVersion({+ agent_id,+ version_index,+ });+ },+ {+ onMutate: (variables) => options?.onMutate?.(variables),+ onError: (error, variables, context) => options?.onError?.(error, variables, context),+ onSuccess: (revertedAgent, variables, context) => {+ queryClient.setQueryData<t.Agent>([QueryKeys.agent, variables.agent_id], revertedAgent);++ const listRes = queryClient.getQueryData<t.AgentListResponse>([+ QueryKeys.agents,+ defaultOrderQuery,+ ]);++ if (listRes) {+ queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {+ ...listRes,+ data: listRes.data.map((agent) => {+ if (agent.id === variables.agent_id) {+ return revertedAgent;+ }+ return agent;+ }),+ });+ }++ return options?.onSuccess?.(revertedAgent, variables, context);+ },+ },+ );+};diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 77dab2732e..d010b2d33c 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -483,6 +483,20 @@"com_ui_agent_recursion_limit_info": "Limits how many steps the agent can take in a run before giving a final response. Default is 25 steps. A step is either an AI API request or a tool usage round. For example, a basic tool interaction takes 3 steps: initial request, tool usage, and follow-up request.","com_ui_agent_shared_to_all": "something needs to go here. was empty","com_ui_agent_var": "{{0}} agent",+ "com_ui_agent_version": "Version",+ "com_ui_agent_version_history": "Version History",+ "com_ui_agent_version_error": "Error fetching versions",+ "com_ui_agent_version_empty": "No versions available",+ "com_ui_agent_version_title": "Version {{versionNumber}}",+ "com_ui_agent_version_restore": "Restore",+ "com_ui_agent_version_restore_confirm": "Are you sure you want to restore this version?",+ "com_ui_agent_version_restore_success": "Version restored successfully",+ "com_ui_agent_version_restore_error": "Failed to restore version",+ "com_ui_agent_version_no_agent": "No agent selected. Please select an agent to view version history.",+ "com_ui_agent_version_unknown_date": "Unknown date",+ "com_ui_agent_version_no_date": "Date not available",+ "com_ui_agent_version_active": "Active Version",+ "com_ui_agent_version_duplicate": "Duplicate version detected. This would create a version identical to Version {{versionIndex}}.","com_ui_agents": "Agents","com_ui_agents_allow_create": "Allow creating Agents","com_ui_agents_allow_share_global": "Allow sharing Agents to all users",@@ -882,4 +896,4 @@"com_ui_zoom": "Zoom","com_user_message": "You","com_warning_resubmit_unsupported": "Resubmitting the AI message is not supported for this endpoint."-}\ No newline at end of file+}diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.tsindex ddca2f6ce4..a7852affe2 100644--- a/packages/data-provider/src/api-endpoints.ts+++ b/packages/data-provider/src/api-endpoints.ts@@ -187,6 +187,8 @@ export const agents = ({ path = '', options }: { path?: string; options?: objectreturn url;};+export const revertAgentVersion = (agent_id: string) => `${agents({ path: `${agent_id}/revert` })}`;+export const files = () => '/api/files';export const images = () => `${files()}/images`;diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.tsindex 0d5b88a8e5..737b252215 100644--- a/packages/data-provider/src/data-service.ts+++ b/packages/data-provider/src/data-service.ts@@ -431,6 +431,14 @@ export const listAgents = (params: a.AgentListParams): Promise<a.AgentListRespon);};+export const revertAgentVersion = ({+ agent_id,+ version_index,+}: {+ agent_id: string;+ version_index: number;+}): Promise<a.Agent> => request.post(endpoints.revertAgentVersion(agent_id), { version_index });+/* Tools */export const getAvailableAgentTools = (): Promise<s.TPlugin[]> => {diff --git a/packages/data-provider/src/keys.ts b/packages/data-provider/src/keys.tsindex fd5ee95087..f9e51dc094 100644--- a/packages/data-provider/src/keys.ts+++ b/packages/data-provider/src/keys.ts@@ -65,6 +65,7 @@ export enum MutationKeys {updateAgentAction = 'updateAgentAction',deleteAction = 'deleteAction',deleteAgentAction = 'deleteAgentAction',+ revertAgentVersion = 'revertAgentVersion',deleteUser = 'deleteUser',updateRole = 'updateRole',enableTwoFactor = 'enableTwoFactor',diff --git a/packages/data-provider/src/types/assistants.ts b/packages/data-provider/src/types/assistants.tsindex 5685c46724..16f6b7d762 100644--- a/packages/data-provider/src/types/assistants.ts+++ b/packages/data-provider/src/types/assistants.ts@@ -222,6 +222,7 @@ export type Agent = {hide_sequential_outputs?: boolean;artifacts?: ArtifactModes;recursion_limit?: number;+ version?: number;};export type TAgentsMap = Record<string, Agent | undefined>;diff --git a/packages/data-provider/src/types/mutations.ts b/packages/data-provider/src/types/mutations.tsindex 72d98b81b6..7e76ba8fd9 100644--- a/packages/data-provider/src/types/mutations.ts+++ b/packages/data-provider/src/types/mutations.ts@@ -129,7 +129,20 @@ export type UpdateAgentVariables = {data: AgentUpdateParams;};-export type UpdateAgentMutationOptions = MutationOptions<Agent, UpdateAgentVariables>;+export type DuplicateVersionError = Error & {+ statusCode?: number;+ details?: {+ duplicateVersion?: any;+ versionIndex?: number+ }+};++export type UpdateAgentMutationOptions = MutationOptions<+ Agent,+ UpdateAgentVariables,+ unknown,+ DuplicateVersionError+>;export type DuplicateAgentBody = {agent_id: string;@@ -159,6 +172,13 @@ export type DeleteAgentActionVariables = {export type DeleteAgentActionOptions = MutationOptions<void, DeleteAgentActionVariables>;+export type RevertAgentVersionVariables = {+ agent_id: string;+ version_index: number;+};++export type RevertAgentVersionOptions = MutationOptions<Agent, RevertAgentVersionVariables>;+export type DeleteConversationOptions = MutationOptions<types.TDeleteConversationResponse,types.TDeleteConversationRequestdiff --git a/packages/data-schemas/src/schema/agent.ts b/packages/data-schemas/src/schema/agent.tsindex 642d281c68..784c4f6c35 100644--- a/packages/data-schemas/src/schema/agent.ts+++ b/packages/data-schemas/src/schema/agent.ts@@ -26,6 +26,7 @@ export interface IAgent extends Omit<Document, 'model'> {conversation_starters?: string[];tool_resources?: unknown;projectIds?: Types.ObjectId[];+ versions?: Omit<IAgent, 'versions'>[];}const agentSchema = new Schema<IAgent>(@@ -115,6 +116,10 @@ const agentSchema = new Schema<IAgent>(ref: 'Project',index: true,},+ versions: {+ type: [Schema.Types.Mixed],+ default: [],+ },},{timestamps: true,