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
import { logger } from '@librechat/data-schemas';
import { AuthType, EToolResources } from 'librechat-data-provider';
import type { TPlugin } from 'librechat-data-provider';
import {
ToolInputError,
getToolkitKey,
checkPluginAuth,
formatToolError,
getToolErrorText,
filterUniquePlugins,
formatToolHttpError,
TOOL_ERROR_FALLBACK,
WOLFRAM_STATUS_TEXT,
} from './format';
describe('format.ts helper functions', () => {
describe('filterUniquePlugins', () => {
it('should return empty array when plugins is undefined', () => {
const result = filterUniquePlugins(undefined);
expect(result).toEqual([]);
});
it('should return empty array when plugins is empty', () => {
const result = filterUniquePlugins([]);
expect(result).toEqual([]);
});
it('should filter out duplicate plugins based on pluginKey', () => {
const plugins: TPlugin[] = [
{ name: 'Plugin1', pluginKey: 'key1', description: 'First plugin' },
{ name: 'Plugin2', pluginKey: 'key2', description: 'Second plugin' },
{ name: 'Plugin1 Duplicate', pluginKey: 'key1', description: 'Duplicate of first' },
{ name: 'Plugin3', pluginKey: 'key3', description: 'Third plugin' },
];
const result = filterUniquePlugins(plugins);
expect(result).toHaveLength(3);
expect(result[0].pluginKey).toBe('key1');
expect(result[1].pluginKey).toBe('key2');
expect(result[2].pluginKey).toBe('key3');
// The first occurrence should be kept
expect(result[0].name).toBe('Plugin1');
});
it('should handle plugins with identical data', () => {
const plugin: TPlugin = { name: 'Plugin', pluginKey: 'key', description: 'Test' };
const plugins: TPlugin[] = [plugin, plugin, plugin];
const result = filterUniquePlugins(plugins);
expect(result).toHaveLength(1);
expect(result[0]).toEqual(plugin);
});
});
describe('checkPluginAuth', () => {
const originalEnv = process.env;
beforeEach(() => {
process.env = { ...originalEnv };
});
afterEach(() => {
process.env = originalEnv;
});
it('should return false when plugin is undefined', () => {
const result = checkPluginAuth(undefined);
expect(result).toBe(false);
});
it('should return false when authConfig is undefined', () => {
const plugin: TPlugin = { name: 'Test', pluginKey: 'test', description: 'Test plugin' };
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should return false when authConfig is empty array', () => {
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should return true when all required auth fields have valid env values', () => {
process.env.API_KEY = 'valid-key';
process.env.SECRET_KEY = 'valid-secret';
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'API_KEY', label: 'API Key', description: 'API Key' },
{ authField: 'SECRET_KEY', label: 'Secret Key', description: 'Secret Key' },
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(true);
});
it('should return false when any required auth field is missing', () => {
process.env.API_KEY = 'valid-key';
// SECRET_KEY is not set
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'API_KEY', label: 'API Key', description: 'API Key' },
{ authField: 'SECRET_KEY', label: 'Secret Key', description: 'Secret Key' },
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should return false when auth field value is empty string', () => {
process.env.API_KEY = '';
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [{ authField: 'API_KEY', label: 'API Key', description: 'API Key' }],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should return false when auth field value is whitespace only', () => {
process.env.API_KEY = ' ';
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [{ authField: 'API_KEY', label: 'API Key', description: 'API Key' }],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should return false when auth field value is USER_PROVIDED', () => {
process.env.API_KEY = AuthType.USER_PROVIDED;
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [{ authField: 'API_KEY', label: 'API Key', description: 'API Key' }],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should handle alternate auth fields with || separator', () => {
process.env.ALTERNATE_KEY = 'valid-key';
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'PRIMARY_KEY||ALTERNATE_KEY', label: 'API Key', description: 'API Key' },
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(true);
});
it('should return true when at least one alternate auth field is valid', () => {
process.env.PRIMARY_KEY = '';
process.env.ALTERNATE_KEY = 'valid-key';
process.env.THIRD_KEY = AuthType.USER_PROVIDED;
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{
authField: 'PRIMARY_KEY||ALTERNATE_KEY||THIRD_KEY',
label: 'API Key',
description: 'API Key',
},
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(true);
});
it('should return true when auth field is marked as optional with no env vars', () => {
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'MISSING_KEY', label: 'API Key', description: 'API Key', optional: true },
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(true);
});
it('should return true when all auth fields are optional', () => {
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'MISSING_KEY_A', label: 'Key A', description: 'Key A', optional: true },
{ authField: 'MISSING_KEY_B', label: 'Key B', description: 'Key B', optional: true },
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(true);
});
it('should return false when required field is missing even if optional field exists', () => {
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'MISSING_KEY', label: 'Required Key', description: 'Required' },
{
authField: 'OPTIONAL_KEY',
label: 'Optional Key',
description: 'Optional',
optional: true,
},
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(false);
});
it('should return true when optional field has no env var but required field is satisfied', () => {
process.env.REQUIRED_KEY = 'valid-key';
const plugin: TPlugin = {
name: 'Test',
pluginKey: 'test',
description: 'Test plugin',
authConfig: [
{ authField: 'REQUIRED_KEY', label: 'Required Key', description: 'Required' },
{
authField: 'OPTIONAL_KEY',
label: 'Optional Key',
description: 'Optional',
optional: true,
},
],
};
const result = checkPluginAuth(plugin);
expect(result).toBe(true);
});
});
describe('getToolkitKey', () => {
it('should return undefined when toolName is undefined', () => {
const toolkits: TPlugin[] = [
{ name: 'Toolkit1', pluginKey: 'toolkit1', description: 'Test toolkit' },
];
const result = getToolkitKey({ toolkits, toolName: undefined });
expect(result).toBeUndefined();
});
it('should return undefined when toolName is empty string', () => {
const toolkits: TPlugin[] = [
{ name: 'Toolkit1', pluginKey: 'toolkit1', description: 'Test toolkit' },
];
const result = getToolkitKey({ toolkits, toolName: '' });
expect(result).toBeUndefined();
});
it('should return undefined when no matching toolkit is found', () => {
const toolkits: TPlugin[] = [
{ name: 'Toolkit1', pluginKey: 'toolkit1', description: 'Test toolkit' },
{ name: 'Toolkit2', pluginKey: 'toolkit2', description: 'Test toolkit' },
];
const result = getToolkitKey({ toolkits, toolName: 'nonexistent_tool' });
expect(result).toBeUndefined();
});
it('should match toolkit when toolName starts with pluginKey', () => {
const toolkits: TPlugin[] = [
{ name: 'Toolkit1', pluginKey: 'toolkit1', description: 'Test toolkit' },
{ name: 'Toolkit2', pluginKey: 'toolkit2', description: 'Test toolkit' },
];
const result = getToolkitKey({ toolkits, toolName: 'toolkit2_function' });
expect(result).toBe('toolkit2');
});
it('should handle image_edit tools with suffix matching', () => {
const toolkits: TPlugin[] = [
{ name: 'Image Editor', pluginKey: 'image_edit_v1', description: 'Image editing' },
{ name: 'Image Editor 2', pluginKey: 'image_edit_v2', description: 'Image editing v2' },
];
const result = getToolkitKey({
toolkits,
toolName: `${EToolResources.image_edit}_function_v2`,
});
expect(result).toBe('image_edit_v2');
});
it('should match the first toolkit when multiple matches are possible', () => {
const toolkits: TPlugin[] = [
{ name: 'Toolkit', pluginKey: 'toolkit', description: 'Base toolkit' },
{ name: 'Toolkit Extended', pluginKey: 'toolkit_extended', description: 'Extended' },
];
const result = getToolkitKey({ toolkits, toolName: 'toolkit_function' });
expect(result).toBe('toolkit');
});
it('should handle empty toolkits array', () => {
const toolkits: TPlugin[] = [];
const result = getToolkitKey({ toolkits, toolName: 'any_tool' });
expect(result).toBeUndefined();
});
it('should handle complex plugin keys with underscores', () => {
const toolkits: TPlugin[] = [
{
name: 'Complex Toolkit',
pluginKey: 'complex_toolkit_with_underscores',
description: 'Complex',
},
];
const result = getToolkitKey({
toolkits,
toolName: 'complex_toolkit_with_underscores_function',
});
expect(result).toBe('complex_toolkit_with_underscores');
});
});
describe('formatToolError', () => {
it('returns the fallback instead of a raw exception message', () => {
const error = new Error(
'request to https://api.example.test/data?lat=1&appid=secret-key failed, reason: ENOTFOUND',
);
expect(formatToolError(error, 'Example')).toBe(`Error: ${TOOL_ERROR_FALLBACK}`);
expect(formatToolError('timeout')).toBe(`Error: ${TOOL_ERROR_FALLBACK}`);
});
it('keeps the message of a tool input error', () => {
expect(formatToolError(new ToolInputError('Could not find coordinates for city: Rome'))).toBe(
'Error: Could not find coordinates for city: Rome',
);
});
it('redacts credentials and emails a tool input error echoes from its arguments', () => {
const text = formatToolError(
new ToolInputError(
'Could not find coordinates for city: sk-proj-PRIVATEKEY123 [email protected]',
),
);
expect(text).toContain('Could not find coordinates for city:');
expect(text).not.toContain('PRIVATEKEY123');
expect(text).not.toContain('[email protected]');
expect(getToolErrorText(new ToolInputError('key=PRIVATEQUERY123 rejected'))).not.toContain(
'PRIVATEQUERY123',
);
});
it('logs only safe metadata for an unapproved failure', () => {
const warn = jest.spyOn(logger, 'warn').mockImplementation(() => logger);
const error = Object.assign(new Error('upstream said PRIVATE-DETAIL'), {
code: 'ECONNRESET',
});
formatToolError(error, 'Example');
expect(warn).toHaveBeenCalledWith('[Example] Tool request failed', { type: 'Error' });
expect(JSON.stringify(warn.mock.calls)).not.toContain('PRIVATE-DETAIL');
warn.mockRestore();
});
it('words an HTTP failure from its status, never its response body', () => {
const httpError = (status: number) =>
Object.assign(new Error('Request failed'), {
response: { status, data: 'PRIVATE-PROVIDER-BODY' },
});
expect(formatToolError(httpError(503), 'Wolfram|Alpha', WOLFRAM_STATUS_TEXT)).toBe(
'Error: Wolfram|Alpha is unavailable; try again later (status 503).',
);
expect(formatToolError(httpError(501), 'Wolfram|Alpha', WOLFRAM_STATUS_TEXT)).toBe(
`Error: ${WOLFRAM_STATUS_TEXT[501]}`,
);
expect(formatToolError(httpError(404), 'Example')).not.toContain('PRIVATE-PROVIDER-BODY');
});
});
describe('getToolErrorText', () => {
it('approves only tool input errors', () => {
expect(getToolErrorText(new ToolInputError('Invalid date format.'))).toBe(
'Invalid date format.',
);
expect(getToolErrorText(new Error('socket hang up'))).toBe(TOOL_ERROR_FALLBACK);
expect(getToolErrorText({ message: 'not an error' })).toBe(TOOL_ERROR_FALLBACK);
});
});
describe('formatToolHttpError', () => {
it.each([
[401, 'Error: Service rejected the configured credentials (status 401).'],
[404, 'Error: Service found no result for this request (status 404).'],
[429, 'Error: Service is rate limiting requests; try again later (status 429).'],
[
400,
'Error: Service rejected the request parameters; check them and try again (status 400).',
],
[503, 'Error: Service is unavailable; try again later (status 503).'],
])('words status %i without provider text', (status, expected) => {
expect(formatToolHttpError('Service', status)).toBe(expected);
});
it('prefers a tool-specific wording for a documented status', () => {
expect(formatToolHttpError('Service', 501, { 501: 'Rephrase the input.' })).toBe(
'Error: Rephrase the input.',
);
});
});
});