From ec1304f68413cf6800cd30ae3e1b7c00b262df3d Mon Sep 17 00:00:00 2001 From: Dustin Healy <54083382+dustinhealy@users.noreply.github.com> Date: Mon, 14 Sep 2026 15:24:47 -0400 Subject: [PATCH] =?UTF-8?q?=F0=9F=9B=85=20fix:=20Preserve=20Agent=20Manage?= =?UTF-8?q?ment=20Upload=20IDs=20(#15840)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: preserve agent management upload IDs with E2E coverage * test: clean up agent management upload fixtures --- e2e/playwright.config.mock.ts | 5 + e2e/setup/agent-management.ts | 58 ++++++ e2e/specs/mock/agent-management-files.spec.ts | 192 ++++++++++++++++++ packages/api/src/agents/files.spec.ts | 8 +- packages/api/src/agents/files.ts | 3 +- 5 files changed, 264 insertions(+), 2 deletions(-) create mode 100644 e2e/setup/agent-management.ts create mode 100644 e2e/specs/mock/agent-management-files.spec.ts diff --git a/e2e/playwright.config.mock.ts b/e2e/playwright.config.mock.ts index c51ea71d81..9cda6f98e1 100644 --- a/e2e/playwright.config.mock.ts +++ b/e2e/playwright.config.mock.ts @@ -2,6 +2,7 @@ import { defineConfig, devices } from '@playwright/test'; import fs from 'fs'; import path from 'path'; import { getLocalE2EEnv, getE2EBaseURL } from './setup/env'; +import { managementAuth } from './setup/agent-management'; const rootPath = path.resolve(__dirname, '..'); const replicaCount = Number(process.env.E2E_REPLICAS || '1'); @@ -186,6 +187,10 @@ function writeRuntimeMockConfig() { process.env.E2E_MODEL_SPECS_ENFORCE === 'true' ? template.replace('\n enforce: false\n', '\n enforce: true\n') : template; + config = config.replace( + ' agents:\n', + ` agents:\n managementApi: ${JSON.stringify({ auth: managementAuth })}\n`, + ); const dynamicMcpConfig = enableDynamicMcp ? { allowedDomain: '- http://127.0.0.1:8766', diff --git a/e2e/setup/agent-management.ts b/e2e/setup/agent-management.ts new file mode 100644 index 0000000000..a6c6ff2924 --- /dev/null +++ b/e2e/setup/agent-management.ts @@ -0,0 +1,58 @@ +import jwt from 'jsonwebtoken'; +import { createServer } from 'http'; +import { generateKeyPairSync, randomUUID } from 'crypto'; + +export const managementUserId = '00000000000000000000a901'; +export const managementTenantId = 'e2e-agent-management'; +const port = Number(process.env.E2E_MANAGEMENT_OIDC_PORT ?? '8792'); +const issuer = `http://127.0.0.1:${port}`; +const audience = 'e2e-agent-management'; +const clientId = 'e2e-management-client'; + +export const managementAuth = { + oidc: { enabled: true, issuer, audience }, + clients: [{ clientId, userId: managementUserId, tenantId: managementTenantId }], +}; + +/** Only the identity provider is a fixture; LibreChat verifies the token over HTTP. */ +export async function startManagementOidc() { + const { privateKey, publicKey } = generateKeyPairSync('rsa', { modulusLength: 2048 }); + const jwk = { + ...publicKey.export({ format: 'jwk' }), + kid: randomUUID(), + alg: 'RS256', + use: 'sig', + }; + const server = createServer((req, res) => { + res.setHeader('Content-Type', 'application/json'); + if (req.url === '/.well-known/openid-configuration') { + res.end(JSON.stringify({ issuer, jwks_uri: `${issuer}/jwks` })); + return; + } + if (req.url === '/jwks') { + res.end(JSON.stringify({ keys: [jwk] })); + return; + } + res.writeHead(404).end(); + }); + await new Promise((resolve, reject) => { + server.once('error', reject); + server.listen(port, '127.0.0.1', resolve); + }); + const token = jwt.sign({ client_id: clientId }, privateKey, { + algorithm: 'RS256', + keyid: jwk.kid, + issuer, + audience, + subject: clientId, + expiresIn: '1h', + }); + return { + token, + close: () => + new Promise((resolve, reject) => { + server.close((error) => (error ? reject(error) : resolve())); + server.closeAllConnections(); + }), + }; +} diff --git a/e2e/specs/mock/agent-management-files.spec.ts b/e2e/specs/mock/agent-management-files.spec.ts new file mode 100644 index 0000000000..20bf4dfae5 --- /dev/null +++ b/e2e/specs/mock/agent-management-files.spec.ts @@ -0,0 +1,192 @@ +import fs from 'fs'; +import path from 'path'; +import mongoose from 'mongoose'; +import { expect, test } from '@playwright/test'; +import { createModels, createMethods, tenantStorage } from '@librechat/data-schemas'; +import type { CodeProvisionRecord, RagEmbedRecord } from './helpers'; +import { + managementUserId, + managementTenantId, + startManagementOidc, +} from '../../setup/agent-management'; +import { applyRuntimeEnv } from '../../setup/runtimeEnv'; +import { CODE_API_BASE, RAG_API_BASE } from './helpers'; +import { withMongo } from './db'; + +const agentsPath = '/api/agents/v1/agents'; +const content = 'Agent management upload regression: violet.\n'; +const stagingPath = path.resolve('uploads', 'temp', managementUserId); + +test.describe('agent management file lifecycle', () => { + test.describe.configure({ mode: 'default' }); + let oidc: Awaited>; + let headers: { Authorization: string }; + + test.beforeAll(async () => { + oidc = await startManagementOidc(); + headers = { Authorization: `Bearer ${oidc.token}` }; + applyRuntimeEnv(); + await mongoose.connect(process.env.MONGO_URI!); + createModels(mongoose); + const methods = createMethods(mongoose); + await tenantStorage.run({ tenantId: managementTenantId }, async () => { + await methods.initializeRoles(); + await methods.seedDefaultRoles(); + await methods.seedSystemGrants(); + await mongoose.models.User.updateOne( + { _id: managementUserId }, + { + $set: { + name: 'Agent Management E2E', + email: 'agent-management@example.test', + emailVerified: true, + provider: 'local', + role: 'ADMIN', + tenantId: managementTenantId, + }, + }, + { upsert: true }, + ); + }); + }); + + test.afterAll(async () => { + try { + // Unlinking intentionally retains files; teardown owns the fixture tenant's data. + await withMongo(async (db) => { + for (const { name } of await db.listCollections({}, { nameOnly: true }).toArray()) { + if (name.startsWith('system.')) { + continue; + } + await db.collection(name).deleteMany({ tenantId: managementTenantId }); + } + }); + await fs.promises.rm(path.resolve('uploads', managementUserId), { + recursive: true, + force: true, + }); + await fs.promises.rm(stagingPath, { recursive: true, force: true }); + } finally { + await mongoose.disconnect(); + await oidc?.close(); + } + }); + + for (const purpose of ['context', 'file_search', 'execute_code']) { + test(`uploads, persists, lists and unlinks ${purpose} files`, async ({ request }) => { + const created = await request.post(agentsPath, { + headers, + data: { name: `Upload ${purpose}`, provider: 'Mock Provider A', model: 'mock-model-a' }, + }); + expect(created.status(), await created.text()).toBe(201); + const { id: agentId } = await created.json(); + const filesPath = `${agentsPath}/${agentId}/files`; + try { + const filename = `${purpose}.txt`; + const uploaded = await request.post(filesPath, { + headers, + multipart: { + purpose, + file: { name: filename, mimeType: 'text/plain', buffer: Buffer.from(content) }, + }, + }); + expect(uploaded.status(), await uploaded.text()).toBe(200); + const file = await uploaded.json(); + expect(file).toMatchObject({ + filename, + bytes: Buffer.byteLength(content), + purposes: [purpose], + }); + expect(file.id).toMatch(/^[a-f\d-]{36}$/i); + + await withMongo(async (db) => { + const stored = await db.collection('files').findOne({ + file_id: file.id, + tenantId: managementTenantId, + user: new mongoose.Types.ObjectId(managementUserId), + }); + expect(stored).not.toBeNull(); + if (purpose === 'context') { + expect(stored?.text).toBe(content); + } else if (purpose === 'file_search') { + expect(stored?.embedded).toBe(true); + } else { + expect(stored?.metadata?.codeEnvRef?.file_id).toBeTruthy(); + } + }); + + if (purpose !== 'context') { + const url = + purpose === 'file_search' + ? `${RAG_API_BASE}/__debug/embedded` + : `${CODE_API_BASE}/__debug/uploads`; + const provisioned = await request.get(url); + expect(provisioned.status()).toBe(200); + const records = await provisioned.json(); + if (purpose === 'file_search') { + expect( + records.embedded.map((record: RagEmbedRecord & { bytes: number }) => ({ + file_id: record.file_id, + entity_id: record.entity_id, + bytes: record.bytes, + })), + ).toContainEqual({ + file_id: file.id, + entity_id: agentId, + bytes: Buffer.byteLength(content), + }); + } else { + expect( + records.uploads.map((record: CodeProvisionRecord & { bytes: number }) => ({ + filename: record.filename, + id: record.id, + bytes: record.bytes, + })), + ).toContainEqual({ filename, id: agentId, bytes: Buffer.byteLength(content) }); + } + } + + const listed = await request.get(filesPath, { headers }); + expect(listed.status()).toBe(200); + expect((await listed.json()).data).toEqual([expect.objectContaining({ id: file.id })]); + const unlinked = await request.delete(`${filesPath}/${file.id}`, { headers }); + expect(unlinked.status(), await unlinked.text()).toBe(200); + expect(await unlinked.json()).toEqual({ id: file.id, deleted: true }); + expect((await (await request.get(filesPath, { headers })).json()).data).toEqual([]); + await withMongo(async (db) => { + expect(await db.collection('files').countDocuments({ file_id: file.id })).toBe(1); + }); + expect(fs.existsSync(stagingPath) ? fs.readdirSync(stagingPath) : []).toEqual([]); + } finally { + const deleted = await request.delete(`${agentsPath}/${agentId}`, { headers }); + expect(deleted.status(), await deleted.text()).toBe(200); + } + }); + } + + test('rejects invalid uploads and cleans staged files', async ({ request }) => { + const created = await request.post(agentsPath, { + headers, + data: { name: 'Rejected uploads', provider: 'Mock Provider A', model: 'mock-model-a' }, + }); + expect(created.status(), await created.text()).toBe(201); + const { id: agentId } = await created.json(); + const filesPath = `${agentsPath}/${agentId}/files`; + try { + for (const [purpose, buffer] of [ + ['unsupported', Buffer.from(content)], + ['context', Buffer.alloc(0)], + ] as const) { + const uploaded = await request.post(filesPath, { + headers, + multipart: { purpose, file: { name: 'invalid.txt', mimeType: 'text/plain', buffer } }, + }); + expect(uploaded.status(), await uploaded.text()).toBe(400); + expect((await (await request.get(filesPath, { headers })).json()).data).toEqual([]); + expect(fs.existsSync(stagingPath) ? fs.readdirSync(stagingPath) : []).toEqual([]); + } + } finally { + expect((await request.delete(`${agentsPath}/${agentId}`, { headers })).status()).toBe(200); + } + }); +}); diff --git a/packages/api/src/agents/files.spec.ts b/packages/api/src/agents/files.spec.ts index 35272464c8..71e2e0b06f 100644 --- a/packages/api/src/agents/files.spec.ts +++ b/packages/api/src/agents/files.spec.ts @@ -45,7 +45,12 @@ const agent = { }; function makeRequest(params: Record): Request { - return { user, params, headers: {} } as unknown as Request; + return { + user, + params, + headers: {}, + file_id: '91a0f989-24cc-4161-a924-9de85c496633', + } as unknown as Request; } function makeResponse(): Response { @@ -237,6 +242,7 @@ describe('Agent Management file handlers', () => { expect(deps.processUpload).toHaveBeenCalledWith(request, response); expect(request.body).toEqual({ + file_id: '91a0f989-24cc-4161-a924-9de85c496633', endpoint: 'Moonshot', endpointType: 'custom', agent_id: 'agent-one', diff --git a/packages/api/src/agents/files.ts b/packages/api/src/agents/files.ts index 1614940bf5..d5786b782e 100644 --- a/packages/api/src/agents/files.ts +++ b/packages/api/src/agents/files.ts @@ -467,7 +467,7 @@ export function createAgentManagementFileHandlers(deps: AgentManagementFileDeps) } } - async function upload(req: Request, res: Response): Promise { + async function upload(req: Request & { file_id?: string }, res: Response): Promise { try { const purpose = req.body?.purpose as string | undefined; if (!req.file || !UPLOAD_PURPOSES.includes(purpose as AgentUploadPurpose)) { @@ -501,6 +501,7 @@ export function createAgentManagementFileHandlers(deps: AgentManagementFileDeps) } req.body = { + file_id: req.file_id, endpoint: authorized.uploadConfig.endpoint, endpointType: authorized.uploadConfig.endpointType, agent_id: req.params.id,