Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🗝️ fix: Protect Model Spec Instructions (#13125)
Danny Avilaca8c212c0dbb
diff --git a/api/server/middleware/buildEndpointOption.js b/api/server/middleware/buildEndpointOption.jsindex cf4f773160..1eaa1ef8d9 100644--- a/api/server/middleware/buildEndpointOption.js+++ b/api/server/middleware/buildEndpointOption.js@@ -1,4 +1,10 @@-const { handleError } = require('@librechat/api');+const {+ handleError,+ applyModelSpecPreset,+ findModelSpecByName,+ isModelSpecEndpointMatch,+ resolveModelSpecPromptPrefixVariables,+} = require('@librechat/api');const { logger } = require('@librechat/data-schemas');const {EndpointURLs,@@ -21,6 +27,8 @@ const buildFunction = {async function buildEndpointOption(req, res, next) {const { endpoint, endpointType } = req.body;+ const isAgents =+ isAgentsEndpoint(endpoint) || req.baseUrl.startsWith(EndpointURLs[EModelEndpoint.agents]);let endpointsConfig;try {@@ -48,6 +56,7 @@ async function buildEndpointOption(req, res, next) {}const appConfig = req.config;+ let appliedModelSpecPrivateFields = new Set();if (appConfig.modelSpecs?.list?.length && appConfig.modelSpecs?.enforce) {/** @type {{ list: TModelSpec[] }}*/const { list } = appConfig.modelSpecs;@@ -57,41 +66,63 @@ async function buildEndpointOption(req, res, next) {return handleError(res, { text: 'No model spec selected' });}- const currentModelSpec = list.find((s) => s.name === spec);+ const currentModelSpec = findModelSpecByName({ list }, spec);if (!currentModelSpec) {return handleError(res, { text: 'Invalid model spec' });}- if (endpoint !== currentModelSpec.preset.endpoint) {+ if (!isModelSpecEndpointMatch(currentModelSpec, endpoint)) {return handleError(res, { text: 'Model spec mismatch' });}try {- currentModelSpec.preset.spec = spec;- parsedBody = parseCompactConvo({+ const result = applyModelSpecPreset({+ modelSpec: currentModelSpec,+ parsedBody: currentModelSpec.preset,endpoint,endpointType,- conversation: currentModelSpec.preset,defaultParamsEndpoint,+ includePresetDefaults: true,});- if (currentModelSpec.iconURL != null && currentModelSpec.iconURL !== '') {- parsedBody.iconURL = currentModelSpec.iconURL;- }+ parsedBody = result.parsedBody;+ appliedModelSpecPrivateFields = result.appliedPrivateFields;} catch (error) {logger.error(`Error parsing model spec for endpoint ${endpoint}`, error);return handleError(res, { text: 'Error parsing model spec' });}} else if (parsedBody.spec && appConfig.modelSpecs?.list) {- // Non-enforced mode: if spec is selected, derive iconURL from model spec- const modelSpec = appConfig.modelSpecs.list.find((s) => s.name === parsedBody.spec);- if (modelSpec?.iconURL) {- parsedBody.iconURL = modelSpec.iconURL;+ const modelSpec = findModelSpecByName(appConfig.modelSpecs, parsedBody.spec);+ if (modelSpec) {+ if (!isModelSpecEndpointMatch(modelSpec, endpoint)) {+ return handleError(res, { text: 'Model spec mismatch' });+ }++ try {+ const result = applyModelSpecPreset({+ modelSpec,+ parsedBody,+ endpoint,+ endpointType,+ defaultParamsEndpoint,+ });+ parsedBody = result.parsedBody;+ appliedModelSpecPrivateFields = result.appliedPrivateFields;+ } catch (error) {+ logger.error(`Error parsing model spec for endpoint ${endpoint}`, error);+ return handleError(res, { text: 'Error parsing model spec' });+ }}}+ if (!isAgents && appliedModelSpecPrivateFields.has('promptPrefix')) {+ parsedBody = resolveModelSpecPromptPrefixVariables(+ parsedBody,+ req.user,+ req.body.clientTimestamp,+ );+ }+try {- const isAgents =- isAgentsEndpoint(endpoint) || req.baseUrl.startsWith(EndpointURLs[EModelEndpoint.agents]);const builder = isAgents? (...args) => buildFunction[EModelEndpoint.agents](req, ...args): buildFunction[endpointType ?? endpoint];diff --git a/api/server/middleware/buildEndpointOption.spec.js b/api/server/middleware/buildEndpointOption.spec.jsindex 5d93acd6bb..9c353b498a 100644--- a/api/server/middleware/buildEndpointOption.spec.js+++ b/api/server/middleware/buildEndpointOption.spec.js@@ -17,6 +17,10 @@ const mockBuildOptions = jest.fn((_endpoint, parsedBody) => ({...parsedBody,endpoint: _endpoint,}));+const mockAgentBuildOptions = jest.fn((_req, endpoint, parsedBody) => ({+ ...parsedBody,+ endpoint,+}));jest.mock('~/server/services/Endpoints/azureAssistants', () => ({buildOptions: mockBuildOptions,@@ -25,7 +29,7 @@ jest.mock('~/server/services/Endpoints/assistants', () => ({buildOptions: mockBuildOptions,}));jest.mock('~/server/services/Endpoints/agents', () => ({- buildOptions: mockBuildOptions,+ buildOptions: mockAgentBuildOptions,}));jest.mock('~/models', () => ({@@ -38,6 +42,7 @@ jest.mock('~/server/services/Config', () => ({}));jest.mock('@librechat/api', () => ({+ ...jest.requireActual('@librechat/api'),handleError: jest.fn(),}));@@ -207,6 +212,183 @@ describe('buildEndpointOption - defaultParamsEndpoint parsing', () => {expect(enforcedResult.maxContextTokens).toBe(50000);});+ it('should restore private model spec preset fields in non-enforced mode', async () => {+ mockGetEndpointsConfig.mockResolvedValue({});++ const modelSpec = {+ name: 'guarded-openai',+ iconURL: 'openAI',+ preset: {+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ promptPrefix: 'private prompt prefix',+ instructions: 'private instructions',+ additional_instructions: 'private additional instructions',+ temperature: 0.2,+ maxContextTokens: 10000,+ },+ };++ const req = createReq(+ {+ endpoint: EModelEndpoint.openAI,+ spec: 'guarded-openai',+ model: 'gpt-4o',+ temperature: 0.8,+ },+ {+ modelSpecs: {+ enforce: false,+ list: [modelSpec],+ },+ },+ );+ req.baseUrl = '/api/agents/chat';++ await buildEndpointOption(req, createRes(), jest.fn());++ expect(req.body.endpointOption.promptPrefix).toBe('private prompt prefix');+ expect(req.body.endpointOption.instructions).toBeUndefined();+ expect(req.body.endpointOption.additional_instructions).toBeUndefined();+ expect(req.body.endpointOption.temperature).toBe(0.8);+ expect(req.body.endpointOption.maxContextTokens).toBeUndefined();+ expect(req.body.endpointOption.iconURL).toBe('openAI');+ });++ it('should reject non-enforced model specs for a different endpoint', async () => {+ mockGetEndpointsConfig.mockResolvedValue({});++ const req = createReq(+ {+ endpoint: EModelEndpoint.openAI,+ spec: 'guarded-google',+ model: 'gpt-4o',+ },+ {+ modelSpecs: {+ enforce: false,+ list: [+ {+ name: 'guarded-google',+ preset: {+ endpoint: EModelEndpoint.google,+ model: 'gemini-pro',+ promptPrefix: 'private google prompt',+ },+ },+ ],+ },+ },+ );+ const res = createRes();+ const next = jest.fn();+ const { handleError } = require('@librechat/api');++ await buildEndpointOption(req, res, next);++ expect(handleError).toHaveBeenCalledWith(res, { text: 'Model spec mismatch' });+ expect(mockAgentBuildOptions).not.toHaveBeenCalled();+ expect(next).not.toHaveBeenCalled();+ });++ it('should restore private model spec examples when the parser supplies an empty default', async () => {+ mockGetEndpointsConfig.mockResolvedValue({});++ const examples = [{ input: { content: 'hello' }, output: { content: 'world' } }];+ const req = createReq(+ {+ endpoint: EModelEndpoint.google,+ spec: 'guarded-google',+ model: 'gemini-pro',+ },+ {+ modelSpecs: {+ enforce: false,+ list: [+ {+ name: 'guarded-google',+ preset: {+ endpoint: EModelEndpoint.google,+ model: 'gemini-pro',+ examples,+ },+ },+ ],+ },+ },+ );+ req.baseUrl = '/api/agents/chat';++ await buildEndpointOption(req, createRes(), jest.fn());++ expect(req.body.endpointOption.examples).toEqual(examples);+ });++ it('should resolve special variables for restored non-agent promptPrefix', async () => {+ mockGetEndpointsConfig.mockResolvedValue({});++ const req = createReq(+ {+ endpoint: EModelEndpoint.assistants,+ spec: 'guarded-assistant',+ assistant_id: 'asst_123',+ },+ {+ modelSpecs: {+ enforce: false,+ list: [+ {+ name: 'guarded-assistant',+ preset: {+ endpoint: EModelEndpoint.assistants,+ assistant_id: 'asst_123',+ promptPrefix: 'Help {{current_user}}.',+ },+ },+ ],+ },+ },+ );+ req.user = { name: 'Ada' };++ await buildEndpointOption(req, createRes(), jest.fn());++ expect(req.body.endpointOption.promptPrefix).toBe('Help Ada.');+ });++ it('should leave restored agent promptPrefix variables for agent initialization', async () => {+ mockGetEndpointsConfig.mockResolvedValue({});++ const req = createReq(+ {+ endpoint: EModelEndpoint.openAI,+ spec: 'guarded-openai',+ model: 'gpt-4o',+ },+ {+ modelSpecs: {+ enforce: false,+ list: [+ {+ name: 'guarded-openai',+ preset: {+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ promptPrefix: 'Help {{current_user}}.',+ },+ },+ ],+ },+ },+ );+ req.baseUrl = '/api/agents/chat';+ req.user = { name: 'Ada' };++ await buildEndpointOption(req, createRes(), jest.fn());++ expect(req.body.endpointOption.promptPrefix).toBe('Help {{current_user}}.');+ });+it('should fall back to OpenAI schema when getEndpointsConfig fails', async () => {mockGetEndpointsConfig.mockRejectedValue(new Error('Config unavailable'));diff --git a/api/server/routes/__tests__/config.spec.js b/api/server/routes/__tests__/config.spec.jsindex d92c56b8bb..52a843116c 100644--- a/api/server/routes/__tests__/config.spec.js+++ b/api/server/routes/__tests__/config.spec.js@@ -322,6 +322,43 @@ describe('GET /api/config', () => {expect(response.body.webSearch).toEqual({ searchProvider: 'tavily' });});+ it('should strip private prompt fields from model spec presets', async () => {+ mockGetAppConfig.mockResolvedValue({+ ...baseAppConfig,+ modelSpecs: {+ enforce: false,+ prioritize: true,+ list: [+ {+ name: 'guarded-spec',+ label: 'Guarded Spec',+ preset: {+ endpoint: 'openAI',+ model: 'gpt-4o',+ promptPrefix: 'private prompt prefix',+ instructions: 'private assistant instructions',+ additional_instructions: 'private additional instructions',+ system: 'private bedrock system',+ context: 'private context',+ examples: [{ input: { content: 'a' }, output: { content: 'b' } }],+ greeting: 'Hello',+ },+ },+ ],+ },+ });+ const app = createApp(mockUser);++ const response = await request(app).get('/api/config');++ expect(response.statusCode).toBe(200);+ expect(response.body.modelSpecs.list[0].preset).toEqual({+ endpoint: 'openAI',+ model: 'gpt-4o',+ greeting: 'Hello',+ });+ });+it('should include full interface config', async () => {mockGetAppConfig.mockResolvedValue(baseAppConfig);const app = createApp(mockUser);diff --git a/api/server/routes/config.js b/api/server/routes/config.jsindex 46f4cc09da..2b9fd6e7ad 100644--- a/api/server/routes/config.js+++ b/api/server/routes/config.js@@ -1,5 +1,10 @@const express = require('express');-const { isEnabled, getBalanceConfig, getCloudFrontConfig } = require('@librechat/api');+const {+ isEnabled,+ getBalanceConfig,+ getCloudFrontConfig,+ sanitizeModelSpecs,+} = require('@librechat/api');const { defaultSocialLogins } = require('librechat-data-provider');const { logger, getTenantId, SystemCapabilities } = require('@librechat/data-schemas');const { hasCapability } = require('~/server/middleware/roles/capabilities');@@ -181,7 +186,7 @@ router.get('/', async function (req, res) {socialLogins: appConfig?.registration?.socialLogins ?? defaultSocialLogins,interface: appConfig?.interfaceConfig,turnstile: appConfig?.turnstileConfig,- modelSpecs: appConfig?.modelSpecs,+ modelSpecs: sanitizeModelSpecs(appConfig?.modelSpecs),balance: balanceConfig,bundlerURL: process.env.SANDPACK_BUNDLER_URL,staticBundlerURL: process.env.SANDPACK_STATIC_BUNDLER_URL,diff --git a/packages/api/src/agents/__tests__/load.spec.ts b/packages/api/src/agents/__tests__/load.spec.tsindex b7c6142d69..2419310b83 100644--- a/packages/api/src/agents/__tests__/load.spec.ts+++ b/packages/api/src/agents/__tests__/load.spec.ts@@ -233,6 +233,26 @@ describe('loadAgent', () => {}});+ test('should use parsed promptPrefix for ephemeral agent instructions', async () => {+ const { EPHEMERAL_AGENT_ID } = Constants;++ const result = await loadAgent(+ {+ req: { user: { id: 'user123' }, body: {} },+ agent_id: EPHEMERAL_AGENT_ID as string,+ endpoint: 'openai',+ model_parameters: {+ model: 'gpt-4',+ promptPrefix: 'Server-side model spec instructions',+ } as unknown as AgentModelParameters,+ },+ deps,+ );++ expect(result?.instructions).toBe('Server-side model spec instructions');+ expect(result?.model_parameters).not.toHaveProperty('promptPrefix');+ });+test('should handle ephemeral agent with undefined ephemeralAgent in body', async () => {const { EPHEMERAL_AGENT_ID } = Constants;diff --git a/packages/api/src/agents/load.ts b/packages/api/src/agents/load.tsindex 05746d1195..66f01d9440 100644--- a/packages/api/src/agents/load.ts+++ b/packages/api/src/agents/load.ts@@ -16,6 +16,7 @@ import type {import { getCustomEndpointConfig } from '~/app/config';const { mcp_all, mcp_delimiter } = Constants;+type ModelParametersWithPromptPrefix = AgentModelParameters & { promptPrefix?: string | null };export interface LoadAgentDeps {getAgent: (searchParameter: { id: string }) => Promise<Agent | null>;@@ -89,7 +90,11 @@ export async function loadEphemeralAgent(}}- const instructions = req.body?.promptPrefix;+ const requestPromptPrefix = req.body?.promptPrefix;+ const { promptPrefix: modelPromptPrefix, ...safeModelParameters } =+ model_parameters as ModelParametersWithPromptPrefix;+ const instructions =+ typeof modelPromptPrefix === 'string' ? modelPromptPrefix : requestPromptPrefix;// Get endpoint config for modelDisplayLabel fallbackconst appConfig = req.config;@@ -122,7 +127,7 @@ export async function loadEphemeralAgent(id: ephemeralId,instructions,provider: endpoint,- model_parameters,+ model_parameters: safeModelParameters as AgentModelParameters,model,tools,};diff --git a/packages/api/src/index.ts b/packages/api/src/index.tsindex 6369ce6ed4..338e86d7cc 100644--- a/packages/api/src/index.ts+++ b/packages/api/src/index.ts@@ -33,6 +33,8 @@ export * from './flow/manager';export * from './middleware';/* Memory */export * from './memory';+/* Model Specs */+export * from './modelSpecs';/* Agents */export * from './agents';/* Prompts */diff --git a/packages/api/src/mcp/registry/MCPServersInitializer.ts b/packages/api/src/mcp/registry/MCPServersInitializer.tsindex 56c6ef486b..7c19f6338f 100644--- a/packages/api/src/mcp/registry/MCPServersInitializer.ts+++ b/packages/api/src/mcp/registry/MCPServersInitializer.ts@@ -159,11 +159,27 @@ export class MCPServersInitializer {logger.info(`${prefix} OAuth Required: ${config.requiresOAuth}`);logger.info(`${prefix} Capabilities: ${config.capabilities}`);logger.info(`${prefix} Tools: ${config.tools}`);- logger.info(`${prefix} Server Instructions: ${config.serverInstructions}`);+ logger.info(+ `${prefix} Server Instructions: ${MCPServersInitializer.formatInstructionsForLogging(+ config.serverInstructions,+ )}`,+ );logger.info(`${prefix} Initialized in: ${config.initDuration ?? 'N/A'}ms`);logger.info(`${prefix} -------------------------------------------------┘`);}+ private static formatInstructionsForLogging(instructions?: string | boolean): string {+ if (!instructions) {+ return 'N/A';+ }++ if (typeof instructions !== 'string') {+ return 'configured';+ }++ return `configured (${instructions.length} chars)`;+ }+// Returns formatted log prefix for server messagesprivate static prefix(serverName: string): string {return `[MCP][${serverName}]`;diff --git a/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.ts b/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.tsindex 03cfa948fc..1e705cb79b 100644--- a/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.ts+++ b/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.ts@@ -458,6 +458,17 @@ describe('MCPServersInitializer', () => {);});+ it('should not log raw server instructions', async () => {+ await MCPServersInitializer.initialize(testConfigs);++ expect(mockLogger.info).not.toHaveBeenCalledWith(+ expect.stringContaining('Instructions for file_tools_server'),+ );+ expect(mockLogger.info).toHaveBeenCalledWith(+ expect.stringContaining('[MCP][file_tools_server] Server Instructions: configured'),+ );+ });+it('should use Promise.allSettled for parallel server initialization', async () => {const allSettledSpy = jest.spyOn(Promise, 'allSettled');diff --git a/packages/api/src/modelSpecs/index.ts b/packages/api/src/modelSpecs/index.tsnew file mode 100644index 0000000000..4e34dd0bac--- /dev/null+++ b/packages/api/src/modelSpecs/index.ts@@ -0,0 +1,189 @@+import {+ parseCompactConvo,+ replaceSpecialVars,+ type EModelEndpoint,+ type TConversation,+ type TModelSpec,+ type TModelSpecPreset,+ type TPreset,+ type TSpecsConfig,+ type TUser,+} from 'librechat-data-provider';++export const PRIVATE_MODEL_SPEC_PRESET_FIELDS = [+ 'promptPrefix',+ 'instructions',+ 'additional_instructions',+ 'system',+ 'context',+ 'examples',+] as const satisfies readonly (keyof TModelSpecPreset)[];++export type PrivateModelSpecPresetField = (typeof PRIVATE_MODEL_SPEC_PRESET_FIELDS)[number];+export type ModelSpecParsedBody = Partial<TConversation | TPreset | TModelSpecPreset> &+ Record<string, unknown>;++export type ApplyModelSpecPresetParams = {+ modelSpec: TModelSpec;+ parsedBody: ModelSpecParsedBody;+ endpoint?: string | null;+ endpointType?: string | null;+ defaultParamsEndpoint?: string | null;+ includePresetDefaults?: boolean;+};++export type ApplyModelSpecPresetResult = {+ parsedBody: ModelSpecParsedBody;+ appliedPrivateFields: Set<PrivateModelSpecPresetField>;+};++function hasModelSpecValue(field: PrivateModelSpecPresetField, value: unknown): boolean {+ if (value == null || value === '') {+ return false;+ }++ if (!Array.isArray(value)) {+ return true;+ }++ if (field === 'examples') {+ return value.some((example) => {+ const input = example?.input?.content;+ const output = example?.output?.content;+ return Boolean(input || output);+ });+ }++ return value.length > 0;+}++function mergeModelSpecPreset(+ modelSpec: TModelSpec,+ parsedBody: ModelSpecParsedBody,+ { includePresetDefaults = false }: Pick<ApplyModelSpecPresetParams, 'includePresetDefaults'> = {},+): ApplyModelSpecPresetResult {+ const preset = modelSpec.preset;+ const merged = {+ ...(includePresetDefaults ? preset : {}),+ ...parsedBody,+ spec: modelSpec.name,+ } as ModelSpecParsedBody;+ const appliedPrivateFields = new Set<PrivateModelSpecPresetField>();++ for (const field of PRIVATE_MODEL_SPEC_PRESET_FIELDS) {+ if (!Object.prototype.hasOwnProperty.call(preset, field)) {+ continue;+ }++ if (includePresetDefaults) {+ appliedPrivateFields.add(field);+ continue;+ }++ if (!hasModelSpecValue(field, parsedBody[field])) {+ (merged as Record<string, unknown>)[field] = preset[field];+ appliedPrivateFields.add(field);+ }+ }++ return { parsedBody: merged, appliedPrivateFields };+}++export function findModelSpecByName(+ modelSpecs: Pick<TSpecsConfig, 'list'> | undefined,+ spec: string | null | undefined,+): TModelSpec | undefined {+ if (!spec) {+ return undefined;+ }++ return modelSpecs?.list?.find((modelSpec) => modelSpec.name === spec);+}++export function isModelSpecEndpointMatch(+ modelSpec: Pick<TModelSpec, 'preset'> | undefined,+ endpoint: string | null | undefined,+): boolean {+ return Boolean(modelSpec && endpoint === modelSpec.preset?.endpoint);+}++export function applyModelSpecPreset({+ modelSpec,+ parsedBody,+ endpoint,+ endpointType,+ defaultParamsEndpoint,+ includePresetDefaults,+}: ApplyModelSpecPresetParams): ApplyModelSpecPresetResult {+ const { parsedBody: conversation, appliedPrivateFields } = mergeModelSpecPreset(+ modelSpec,+ parsedBody,+ {+ includePresetDefaults,+ },+ );+ const reparsedBody = parseCompactConvo({+ endpoint: endpoint as EModelEndpoint | undefined,+ endpointType: endpointType as EModelEndpoint | null | undefined,+ conversation,+ defaultParamsEndpoint,+ });++ if (!reparsedBody) {+ throw new Error('Model spec preset produced an empty parsed body');+ }++ const modelSpecParsedBody = reparsedBody as ModelSpecParsedBody;+ if (modelSpec.iconURL != null && modelSpec.iconURL !== '') {+ modelSpecParsedBody.iconURL = modelSpec.iconURL;+ }++ return { parsedBody: modelSpecParsedBody, appliedPrivateFields };+}++export function resolveModelSpecPromptPrefixVariables<T extends { promptPrefix?: string | null }>(+ parsedBody: T,+ user?: TUser | null,+ now?: string | number | Date,+): T {+ if (typeof parsedBody.promptPrefix !== 'string') {+ return parsedBody;+ }++ return {+ ...parsedBody,+ promptPrefix: replaceSpecialVars({+ text: parsedBody.promptPrefix,+ user,+ now,+ }),+ };+}++export function sanitizeModelSpecs<T extends Partial<TSpecsConfig> | null | undefined>(+ modelSpecs: T,+): T {+ if (!modelSpecs?.list || !Array.isArray(modelSpecs.list)) {+ return modelSpecs;+ }++ return {+ ...modelSpecs,+ list: modelSpecs.list.map((modelSpec) => {+ const preset = modelSpec?.preset;+ if (!preset || typeof preset !== 'object') {+ return modelSpec;+ }++ const sanitizedPreset = { ...preset };+ for (const field of PRIVATE_MODEL_SPEC_PRESET_FIELDS) {+ delete sanitizedPreset[field];+ }++ return {+ ...modelSpec,+ preset: sanitizedPreset,+ };+ }),+ } as T;+}diff --git a/packages/api/src/modelSpecs/modelSpecs.test.ts b/packages/api/src/modelSpecs/modelSpecs.test.tsnew file mode 100644index 0000000000..a617cd9442--- /dev/null+++ b/packages/api/src/modelSpecs/modelSpecs.test.ts@@ -0,0 +1,149 @@+import { EModelEndpoint } from 'librechat-data-provider';+import type { TModelSpec } from 'librechat-data-provider';+import {+ applyModelSpecPreset,+ findModelSpecByName,+ isModelSpecEndpointMatch,+ resolveModelSpecPromptPrefixVariables,+ sanitizeModelSpecs,+} from './index';++describe('modelSpecs helpers', () => {+ it('should strip private prompt fields from model spec presets', () => {+ const modelSpecs = {+ enforce: false,+ prioritize: true,+ list: [+ {+ name: 'guarded-spec',+ label: 'Guarded Spec',+ preset: {+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ promptPrefix: 'private prompt prefix',+ instructions: 'private assistant instructions',+ additional_instructions: 'private additional instructions',+ system: 'private bedrock system',+ context: 'private context',+ examples: [{ input: { content: 'a' }, output: { content: 'b' } }],+ greeting: 'Hello',+ },+ },+ ],+ };++ expect(sanitizeModelSpecs(modelSpecs).list[0].preset).toEqual({+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ greeting: 'Hello',+ });+ });++ it('should restore only private fields for non-enforced model specs', () => {+ const modelSpec: TModelSpec = {+ name: 'guarded-openai',+ label: 'Guarded OpenAI',+ iconURL: EModelEndpoint.openAI,+ preset: {+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ promptPrefix: 'private prompt prefix',+ instructions: 'private instructions',+ additional_instructions: 'private additional instructions',+ temperature: 0.2,+ maxContextTokens: 10000,+ },+ };++ const { parsedBody, appliedPrivateFields } = applyModelSpecPreset({+ modelSpec,+ parsedBody: {+ endpoint: EModelEndpoint.openAI,+ spec: 'guarded-openai',+ model: 'gpt-4o',+ temperature: 0.8,+ },+ endpoint: EModelEndpoint.openAI,+ });++ expect(parsedBody.promptPrefix).toBe('private prompt prefix');+ expect(parsedBody.instructions).toBeUndefined();+ expect(parsedBody.additional_instructions).toBeUndefined();+ expect(parsedBody.temperature).toBe(0.8);+ expect(parsedBody.maxContextTokens).toBeUndefined();+ expect(parsedBody.iconURL).toBe(EModelEndpoint.openAI);+ expect(appliedPrivateFields.has('promptPrefix')).toBe(true);+ });++ it('should restore preset defaults when model specs are enforced', () => {+ const modelSpec: TModelSpec = {+ name: 'enforced-openai',+ label: 'Enforced OpenAI',+ preset: {+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ promptPrefix: 'private prompt prefix',+ temperature: 0.2,+ },+ };++ const { parsedBody } = applyModelSpecPreset({+ modelSpec,+ parsedBody: modelSpec.preset,+ endpoint: EModelEndpoint.openAI,+ includePresetDefaults: true,+ });++ expect(parsedBody.spec).toBe('enforced-openai');+ expect(parsedBody.promptPrefix).toBe('private prompt prefix');+ expect(parsedBody.temperature).toBe(0.2);+ });++ it('should restore private examples when parser supplies an empty default', () => {+ const examples = [{ input: { content: 'hello' }, output: { content: 'world' } }];+ const modelSpec: TModelSpec = {+ name: 'guarded-google',+ label: 'Guarded Google',+ preset: {+ endpoint: EModelEndpoint.google,+ model: 'gemini-pro',+ examples,+ },+ };++ const { parsedBody } = applyModelSpecPreset({+ modelSpec,+ parsedBody: {+ endpoint: EModelEndpoint.google,+ spec: 'guarded-google',+ model: 'gemini-pro',+ },+ endpoint: EModelEndpoint.google,+ });++ expect(parsedBody.examples).toEqual(examples);+ });++ it('should find specs and validate endpoint matches', () => {+ const modelSpec: TModelSpec = {+ name: 'guarded-openai',+ label: 'Guarded OpenAI',+ preset: {+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ },+ };++ expect(findModelSpecByName({ list: [modelSpec] }, 'guarded-openai')).toBe(modelSpec);+ expect(isModelSpecEndpointMatch(modelSpec, EModelEndpoint.openAI)).toBe(true);+ expect(isModelSpecEndpointMatch(modelSpec, EModelEndpoint.google)).toBe(false);+ });++ it('should resolve special variables in model spec prompt prefixes', () => {+ expect(+ resolveModelSpecPromptPrefixVariables({ promptPrefix: 'Help {{current_user}}.' }, {+ name: 'Ada',+ } as never).promptPrefix,+ ).toBe('Help Ada.');+ });+});