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 {
Constants,
splitMCPToolKey,
splitToolCallName,
normalizeMCPToolKey,
buildServerNameAliases,
stripServerNamePrefix,
stripServerNamePrefixes,
} from './config';
describe('splitMCPToolKey', () => {
it('splits a normal single-delimiter key like String.split would', () => {
expect(splitMCPToolKey('search_mcp_myserver')).toEqual(['search', 'myserver']);
});
it('returns an undefined server name when there is no delimiter', () => {
expect(splitMCPToolKey('plainToolName')).toEqual(['plainToolName', undefined]);
});
it('resolves a raw tool name containing the delimiter via the last occurrence', () => {
expect(splitMCPToolKey('gitlab-get_mcp_server_version_mcp_gitlab')).toEqual([
'gitlab-get_mcp_server_version',
'gitlab',
]);
});
it('resolves a server name containing the delimiter when known names are supplied', () => {
expect(splitMCPToolKey('search_mcp_Google_mcp_Workspace', ['Google_mcp_Workspace'])).toEqual([
'search',
'Google_mcp_Workspace',
]);
});
it('prefers the longest matching configured server name', () => {
expect(
splitMCPToolKey('search_mcp_Google_mcp_Workspace', ['Workspace', 'Google_mcp_Workspace']),
).toEqual(['search', 'Google_mcp_Workspace']);
});
it('falls back to the last delimiter when no configured name matches', () => {
expect(splitMCPToolKey('gitlab-get_mcp_server_version_mcp_gitlab', ['other'])).toEqual([
'gitlab-get_mcp_server_version',
'gitlab',
]);
});
it('still resolves the tool half when both halves contain the delimiter', () => {
expect(splitMCPToolKey('a_mcp_b_mcp_Google_mcp_Workspace', ['Google_mcp_Workspace'])).toEqual([
'a_mcp_b',
'Google_mcp_Workspace',
]);
});
});
describe('splitToolCallName', () => {
const d = Constants.mcp_delimiter;
it('treats a synthetic OAuth call as oauth plus the full server name', () => {
expect(splitToolCallName(`oauth${d}foo${d}bar`)).toEqual(['oauth', `foo${d}bar`]);
});
it('keeps a normalized server name that itself contains the delimiter', () => {
expect(splitToolCallName(`oauth${d}oauth${d}server`)).toEqual(['oauth', `oauth${d}server`]);
});
it('resolves a real tool key whose raw name contains the delimiter', () => {
expect(splitToolCallName(`gitlab-get${d}server_version${d}gitlab`)).toEqual([
`gitlab-get${d}server_version`,
'gitlab',
]);
});
it('resolves a real tool key against configured server names when supplied', () => {
expect(splitToolCallName(`search${d}Google${d}Workspace`, [`Google${d}Workspace`])).toEqual([
'search',
`Google${d}Workspace`,
]);
});
});
describe('splitToolCallName with configured server names', () => {
const d = Constants.mcp_delimiter;
it('reads a real tool whose own name starts with the oauth prefix', () => {
expect(splitToolCallName(`oauth${d}reset${d}github`, ['github'])).toEqual([
`oauth${d}reset`,
'github',
]);
});
it('still resolves a synthetic OAuth call for a configured server', () => {
expect(splitToolCallName(`oauth${d}github`, ['github'])).toEqual(['oauth', 'github']);
});
it('resolves a synthetic OAuth call for a delimiter-bearing configured server', () => {
expect(splitToolCallName(`oauth${d}foo${d}bar`, [`foo${d}bar`])).toEqual([
'oauth',
`foo${d}bar`,
]);
});
});
describe('splitMCPToolKey boundary alignment', () => {
const d = Constants.mcp_delimiter;
it('ignores a configured name that is not delimiter-aligned in the key', () => {
/** `server` is a bare suffix of `myserver`, not a segment. Matching on
* `endsWith(name)` instead of `endsWith(delimiter + name)` would route the
* call to a different configured server than the agent authorized. */
expect(splitMCPToolKey(`search${d}myserver`, ['server'])).toEqual(['search', 'myserver']);
});
it('treats an empty known-name list the same as no list', () => {
expect(splitMCPToolKey(`gitlab-get${d}server_version${d}gitlab`, [])).toEqual([
`gitlab-get${d}server_version`,
'gitlab',
]);
});
it('requires the configured name to be normalized to match the key', () => {
/** Keys embed `normalizeServerName`'s output, so callers must normalize their
* candidate list; a raw name with spaces can never align. */
expect(splitMCPToolKey(`search${d}Google_mcp_Workspace`, ['Google_mcp_Workspace'])).toEqual([
'search',
'Google_mcp_Workspace',
]);
});
});
describe('buildServerNameAliases', () => {
it('maps normalized forms back to raw config names, including identity entries', () => {
const aliases = buildServerNameAliases(['plain', 'Connector: Company']);
expect(aliases.get('plain')).toBe('plain');
expect(aliases.get('Connector__Company')).toBe('Connector: Company');
expect(aliases.get('Connector: Company')).toBeUndefined();
});
it('skips empty names', () => {
expect(buildServerNameAliases(['', 'srv']).size).toBe(1);
});
it('resolves normalized-name collisions to the FIRST configured name deterministically', () => {
/** `Sales Force` and `Sales:Force` both normalize to `Sales_Force`; their
* tool keys are inherently ambiguous, so routing must at least be stable
* (the collision itself is warned about at context resolution). */
const aliases = buildServerNameAliases(['Sales Force', 'Sales:Force']);
expect(aliases.get('Sales_Force')).toBe('Sales Force');
});
it('an identity name owns its slot regardless of configuration order', () => {
/** A server literally named `Sales_Force` must never have its keys
* rerouted to a special-character server that normalizes onto it. */
expect(buildServerNameAliases(['Sales Force', 'Sales_Force']).get('Sales_Force')).toBe(
'Sales_Force',
);
expect(buildServerNameAliases(['Sales_Force', 'Sales Force']).get('Sales_Force')).toBe(
'Sales_Force',
);
});
});
describe('normalizeMCPToolKey', () => {
const d = Constants.mcp_delimiter;
it('rewrites the server segment of a raw-keyed tool to its normalized form', () => {
expect(normalizeMCPToolKey(`search${d}Connector: Company`, ['Connector: Company'])).toBe(
`search${d}Connector__Company`,
);
});
it('is a no-op for already-normalized keys and safe server names', () => {
expect(normalizeMCPToolKey(`search${d}Connector__Company`, ['Connector: Company'])).toBe(
`search${d}Connector__Company`,
);
expect(normalizeMCPToolKey(`search${d}plain`, ['plain'])).toBe(`search${d}plain`);
});
it('is a no-op when no configured raw name matches (unconfigured or non-MCP keys)', () => {
expect(normalizeMCPToolKey(`search${d}gone server`, ['Connector: Company'])).toBe(
`search${d}gone server`,
);
expect(normalizeMCPToolKey('web_search', ['Connector: Company'])).toBe('web_search');
});
it('resolves the boundary by longest raw match, preserving delimiter-bearing tool names', () => {
/** The tool half may itself contain the delimiter (gateway-prefixed names). */
expect(normalizeMCPToolKey(`gitlab-get${d}server_version${d}My Server`, ['My Server'])).toBe(
`gitlab-get${d}server_version${d}My_Server`,
);
/** `normalizeServerName` strips the trailing `_` it substitutes for `!`. */
expect(normalizeMCPToolKey(`search${d}My${d}Server!`, ['Server!', `My${d}Server!`])).toBe(
`search${d}My${d}Server`,
);
});
});
describe('splitToolCallName oauth precedence', () => {
const d = Constants.mcp_delimiter;
it('falls back to the oauth prefix when a list is supplied but nothing matches', () => {
/** Pins the precedence rule: the configured branch must not return its
* last-delimiter result when no configured name actually matched. */
expect(splitToolCallName(`oauth${d}foo${d}bar`, ['github'])).toEqual(['oauth', `foo${d}bar`]);
});
it('prefers a matching configured server over the oauth prefix', () => {
expect(splitToolCallName(`oauth${d}reset${d}github`, ['github'])).toEqual([
`oauth${d}reset`,
'github',
]);
});
});
describe('stripServerNamePrefix', () => {
it('strips a leading server-name prefix from the tool name', () => {
expect(stripServerNamePrefix('acme_trace_top_time_consuming_operations', 'acme')).toBe(
'trace_top_time_consuming_operations',
);
});
it('matches the prefix case-insensitively', () => {
/** Display-cased server names ("Acme") conventionally prefix their
* tools in lowercase — the redundancy is the same either way. */
expect(stripServerNamePrefix('acme_list_services', 'Acme')).toBe('list_services');
});
it('returns the name unchanged when the prefix does not match', () => {
expect(stripServerNamePrefix('github_create_issue', 'acme')).toBe('github_create_issue');
});
it('requires the underscore separator, not a bare substring match', () => {
expect(stripServerNamePrefix('acmecorp_tool', 'acme')).toBe('acmecorp_tool');
});
it('keeps a name that is exactly the server name or would strip to empty', () => {
expect(stripServerNamePrefix('acme', 'acme')).toBe('acme');
expect(stripServerNamePrefix('acme_', 'acme')).toBe('acme_');
});
});
describe('stripServerNamePrefixes', () => {
it('maps every raw name to its stripped model-facing name', () => {
const map = stripServerNamePrefixes(['acme_search', 'list_services'], 'acme');
expect(map.get('acme_search')).toBe('search');
expect(map.get('list_services')).toBe('list_services');
});
it('keeps the prefixed name when stripping would collide with a bare sibling', () => {
/** A server exposing BOTH `search` and `acme_search` must keep two
* distinct keys — stripping would collapse them into one. */
const map = stripServerNamePrefixes(['search', 'acme_search'], 'acme');
expect(map.get('search')).toBe('search');
expect(map.get('acme_search')).toBe('acme_search');
});
it('keeps both raw names when case-variant prefixed siblings strip to the same result', () => {
/** The prefix match is case-insensitive, so `acme_Foo` and `Acme_Foo` are
* distinct upstream tools with the SAME stripped remainder — both must
* fall back to their raw names or one silently overwrites the other. */
const map = stripServerNamePrefixes(['acme_Foo', 'Acme_Foo'], 'acme');
expect(map.get('acme_Foo')).toBe('acme_Foo');
expect(map.get('Acme_Foo')).toBe('Acme_Foo');
});
it('collisions do not suppress stripping of unrelated siblings', () => {
const map = stripServerNamePrefixes(['search', 'acme_search', 'acme_trace'], 'acme');
expect(map.get('acme_trace')).toBe('trace');
});
it('reserves every sibling raw name, even when that sibling itself strips', () => {
/** Keys persisted BEFORE stripping embed raw names: if `acme_acme_foo`
* stripped to `acme_foo`, a pre-rollout reference to the REAL `acme_foo`
* would exact-match the wrong tool in the same snapshot. */
const map = stripServerNamePrefixes(['acme_foo', 'acme_acme_foo'], 'acme');
expect(map.get('acme_foo')).toBe('foo');
expect(map.get('acme_acme_foo')).toBe('acme_acme_foo');
});
it('resolves secondary collisions introduced by a fallback to a raw name', () => {
/** `acme_foo` falls back to raw because of the bare `foo`, which then
* collides with `acme_acme_foo`'s stripped result — the guard must
* iterate until no two final names coincide. */
const map = stripServerNamePrefixes(['foo', 'acme_foo', 'acme_acme_foo'], 'acme');
expect(map.get('foo')).toBe('foo');
expect(map.get('acme_foo')).toBe('acme_foo');
expect(map.get('acme_acme_foo')).toBe('acme_acme_foo');
expect(new Set(map.values()).size).toBe(3);
});
it('never strips a remainder that equals a synthetic MCP marker', () => {
/** `sys__all__sys` keys expand to every server tool, `sys__server__sys`
* keys are skipped as UI placeholders, and `oauth${mcp_delimiter}` names
* get OAuth-only handling in the client stream handlers — a real
* upstream tool must not be renamed onto any of them. */
expect(stripServerNamePrefix(`acme_${Constants.mcp_all}`, 'acme')).toBe(
`acme_${Constants.mcp_all}`,
);
expect(stripServerNamePrefix(`acme_${Constants.mcp_server}`, 'acme')).toBe(
`acme_${Constants.mcp_server}`,
);
expect(stripServerNamePrefix('acme_oauth', 'acme')).toBe('acme_oauth');
/** Each marker is consumed by PREFIX (`isMCPAllPlaceholder`, the
* server-pin skip, the client's OAuth classification), so the whole
* `${marker}${mcp_delimiter}` namespace stays raw, not just the exact
* name. */
expect(stripServerNamePrefix(`acme_oauth${Constants.mcp_delimiter}reset`, 'acme')).toBe(
`acme_oauth${Constants.mcp_delimiter}reset`,
);
expect(
stripServerNamePrefix(`acme_${Constants.mcp_all}${Constants.mcp_delimiter}reset`, 'acme'),
).toBe(`acme_${Constants.mcp_all}${Constants.mcp_delimiter}reset`);
expect(
stripServerNamePrefix(`acme_${Constants.mcp_server}${Constants.mcp_delimiter}reset`, 'acme'),
).toBe(`acme_${Constants.mcp_server}${Constants.mcp_delimiter}reset`);
/** `mcp_` opens the server-scoped pluginKey namespace and
* `lc_transfer_to_` the agent-handoff namespace — pre-strip tool keys
* could never enter either. */
expect(stripServerNamePrefix('acme_mcp_status', 'acme')).toBe('acme_mcp_status');
expect(stripServerNamePrefix('acme_lc_transfer_to_status', 'acme')).toBe(
'acme_lc_transfer_to_status',
);
});
it('never flips isActionTool classification for the produced key', () => {
/** `isActionTool` compares the FIRST `_action_` and `_mcp_` positions;
* stripping moves `_mcp_` earlier, so a server whose normalized name
* contains `_action_` (e.g. "svc action v1") would see a real MCP tool
* reclassified as an OpenAPI action and bypass MCP authorization. */
expect(stripServerNamePrefix('svc_action_v1_report', 'svc_action_v1')).toBe(
'svc_action_v1_report',
);
/** A remainder containing `_action_` in the tool half does not flip and
* still strips. */
expect(stripServerNamePrefix('acme_do_action_thing', 'acme')).toBe('do_action_thing');
});
});