Skip to content

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

🧩 fix: Harden Agent Skill Lifecycles End to End (#14429)

Danny Avilaf3159f98913b
diff --git a/api/server/services/Endpoints/agents/addedConvo.js b/api/server/services/Endpoints/agents/addedConvo.js
index 09fad7a67f..837b1840f5 100644
--- a/api/server/services/Endpoints/agents/addedConvo.js
+++ b/api/server/services/Endpoints/agents/addedConvo.js
@@ -10,7 +10,7 @@ const {
const { isEphemeralAgentId } = require('librechat-data-provider');
const { filterFilesByAgentAccess } = require('~/server/services/Files/permissions');
const { getMCPServerTools } = require('~/server/services/Config');
-const { canAuthorSkillFiles } = require('./skillDeps');
+const { getSkillDbMethods, canAuthorSkillFiles } = require('./skillDeps');
const db = require('~/models');
const loadAddedAgent = (params) =>
@@ -97,6 +97,7 @@ const processAddedConvo = async ({
});
try {
+ const skillDbMethods = getSkillDbMethods();
const addedAgent = await loadAddedAgent({ req, conversation: addedConvo, primaryAgent });
if (!addedAgent) {
return { userMCPAuthMap };
@@ -138,7 +139,7 @@ const processAddedConvo = async ({
const resolvedSkillIds = await resolveModelSpecSkillIds({
names: selectedModelSpec.skills,
accessibleSkillIds,
- getSkillByName: db.getSkillByName,
+ getSkillByName: skillDbMethods.getSkillByName,
});
addedAgent.skills_enabled = true;
addedAgent.skills = resolvedSkillIds.map((id) => id.toString());
@@ -195,9 +196,9 @@ const processAddedConvo = async ({
getToolFilesByIds: db.getToolFilesByIds,
getCodeGeneratedFiles: db.getCodeGeneratedFiles,
filterFilesByAgentAccess,
- listSkillsByAccess: db.listSkillsByAccess,
- listAlwaysApplySkills: db.listAlwaysApplySkills,
- getSkillByName: db.getSkillByName,
+ listSkillsByAccess: skillDbMethods.listSkillsByAccess,
+ listAlwaysApplySkills: skillDbMethods.listAlwaysApplySkills,
+ getSkillByName: skillDbMethods.getSkillByName,
},
);
diff --git a/api/server/services/Endpoints/agents/addedConvo.spec.js b/api/server/services/Endpoints/agents/addedConvo.spec.js
index cca3372bbd..89e8b0af0a 100644
--- a/api/server/services/Endpoints/agents/addedConvo.spec.js
+++ b/api/server/services/Endpoints/agents/addedConvo.spec.js
@@ -4,8 +4,12 @@ const mockLoadAddedAgent = jest.fn();
const mockResolveAgentScopedSkillIds = jest.fn();
const mockResolveModelSpecSkillIds = jest.fn();
const mockCanAuthorSkillFiles = jest.fn();
+const mockGetSkillDbMethods = jest.fn();
const mockGetAgent = jest.fn();
const mockGetMCPServerTools = jest.fn();
+const mockRegistryGetSkillByName = jest.fn();
+const mockRegistryListSkillsByAccess = jest.fn();
+const mockRegistryListAlwaysApplySkills = jest.fn();
jest.mock('@librechat/data-schemas', () => ({
logger: {
@@ -35,6 +39,7 @@ jest.mock('~/server/services/Config', () => ({
jest.mock('./skillDeps', () => ({
canAuthorSkillFiles: (...args) => mockCanAuthorSkillFiles(...args),
+ getSkillDbMethods: () => mockGetSkillDbMethods(),
}));
jest.mock('~/models', () => ({
@@ -45,7 +50,6 @@ jest.mock('~/models', () => ({
}));
const { processAddedConvo } = require('./addedConvo');
-const db = require('~/models');
const { Constants } = require('librechat-data-provider');
const makeReq = () => ({ user: { id: 'u1', role: 'USER' } });
@@ -72,6 +76,11 @@ describe('processAddedConvo', () => {
);
mockResolveModelSpecSkillIds.mockResolvedValue([]);
mockCanAuthorSkillFiles.mockReturnValue(false);
+ mockGetSkillDbMethods.mockReturnValue({
+ getSkillByName: mockRegistryGetSkillByName,
+ listSkillsByAccess: mockRegistryListSkillsByAccess,
+ listAlwaysApplySkills: mockRegistryListAlwaysApplySkills,
+ });
});
const baseParams = (overrides = {}) => ({
@@ -125,6 +134,75 @@ describe('processAddedConvo', () => {
);
});
+ it('keeps deployment-aware skill metadata on a persisted added-agent config', async () => {
+ const deploymentSkillId = { toString: () => 'deployment-skill' };
+ const agentConfigs = new Map();
+ const initializedConfig = {
+ id: 'persisted-added-agent',
+ additional_instructions: '<skill_catalog>deployment-skill</skill_catalog>',
+ manualSkillPrimes: [],
+ alwaysApplySkillPrimes: [
+ {
+ _id: 'deployment-skill',
+ name: 'deployment-skill',
+ body: 'deployment skill body',
+ },
+ ],
+ toolDefinitions: [{ name: 'skill' }],
+ userMCPAuthMap: undefined,
+ };
+
+ mockLoadAddedAgent.mockResolvedValue({
+ id: 'persisted-added-agent',
+ provider: 'openai',
+ skills_enabled: true,
+ skills: ['deployment-skill'],
+ });
+ mockResolveAgentScopedSkillIds.mockReturnValue([deploymentSkillId]);
+ mockInitializeAgent.mockResolvedValue(initializedConfig);
+
+ await processAddedConvo(
+ baseParams({
+ accessibleSkillIds: [deploymentSkillId],
+ editableSkillIds: [deploymentSkillId],
+ skillsCapabilityEnabled: true,
+ agentConfigs,
+ }),
+ );
+
+ expect(mockResolveModelSpecSkillIds).not.toHaveBeenCalled();
+ expect(mockInitializeAgent).toHaveBeenCalledWith(
+ expect.objectContaining({
+ agent: expect.objectContaining({
+ id: 'persisted-added-agent',
+ skills_enabled: true,
+ skills: ['deployment-skill'],
+ }),
+ accessibleSkillIds: [deploymentSkillId],
+ }),
+ expect.objectContaining({
+ listSkillsByAccess: mockRegistryListSkillsByAccess,
+ listAlwaysApplySkills: mockRegistryListAlwaysApplySkills,
+ getSkillByName: mockRegistryGetSkillByName,
+ }),
+ );
+ expect(agentConfigs.get('persisted-added-agent')).toBe(initializedConfig);
+ expect(agentConfigs.get('persisted-added-agent')).toEqual(
+ expect.objectContaining({
+ additional_instructions: '<skill_catalog>deployment-skill</skill_catalog>',
+ manualSkillPrimes: [],
+ alwaysApplySkillPrimes: [
+ expect.objectContaining({
+ name: 'deployment-skill',
+ body: 'deployment skill body',
+ }),
+ ],
+ toolDefinitions: [expect.objectContaining({ name: 'skill' })],
+ }),
+ );
+ expect(mockGetSkillDbMethods).toHaveBeenCalledTimes(1);
+ });
+
it('resolves and forwards model-spec skill scope for added ephemeral agents', async () => {
const accessibleSkillId = { toString: () => 'accessible-skill' };
const editableSkillId = { toString: () => 'editable-skill' };
@@ -181,7 +259,7 @@ describe('processAddedConvo', () => {
expect(mockResolveModelSpecSkillIds).toHaveBeenCalledWith({
names: ['finance-analyst'],
accessibleSkillIds: [accessibleSkillId],
- getSkillByName: db.getSkillByName,
+ getSkillByName: mockRegistryGetSkillByName,
});
expect(mockResolveAgentScopedSkillIds).toHaveBeenNthCalledWith(1, {
agent: expect.objectContaining({
@@ -222,10 +300,11 @@ describe('processAddedConvo', () => {
defaultActiveOnShare: true,
}),
expect.objectContaining({
- listSkillsByAccess: db.listSkillsByAccess,
- listAlwaysApplySkills: db.listAlwaysApplySkills,
- getSkillByName: db.getSkillByName,
+ listSkillsByAccess: mockRegistryListSkillsByAccess,
+ listAlwaysApplySkills: mockRegistryListAlwaysApplySkills,
+ getSkillByName: mockRegistryGetSkillByName,
}),
);
+ expect(mockGetSkillDbMethods).toHaveBeenCalledTimes(1);
});
});
diff --git a/api/server/services/Endpoints/agents/initialize.js b/api/server/services/Endpoints/agents/initialize.js
index 50ab851aee..9cc8cba7d1 100644
--- a/api/server/services/Endpoints/agents/initialize.js
+++ b/api/server/services/Endpoints/agents/initialize.js
@@ -402,7 +402,7 @@ const initializeClient = async ({ req, res, signal, endpointOption, jobCreatedAt
const resolvedSkillIds = await resolveModelSpecSkillIds({
names: selectedModelSpec.skills,
accessibleSkillIds,
- getSkillByName: db.getSkillByName,
+ getSkillByName: skillDbMethods.getSkillByName,
});
primaryAgent.skills_enabled = true;
primaryAgent.skills = resolvedSkillIds.map((id) => id.toString());
diff --git a/api/server/services/Endpoints/agents/initialize.spec.js b/api/server/services/Endpoints/agents/initialize.spec.js
index c9f4cd4da9..dd3a4a86ca 100644
--- a/api/server/services/Endpoints/agents/initialize.spec.js
+++ b/api/server/services/Endpoints/agents/initialize.spec.js
@@ -79,7 +79,7 @@ jest.mock('~/cache', () => ({
}));
const { initializeClient } = require('./initialize');
-const { getSkillToolDeps } = require('./skillDeps');
+const { getSkillDbMethods, getSkillToolDeps } = require('./skillDeps');
const { getModelsConfig } = require('~/server/controllers/ModelController');
const { logger } = require('@librechat/data-schemas');
const { User, AclEntry } = require('~/db/models');
@@ -360,6 +360,63 @@ describe('initializeClient — processAgent ACL gate', () => {
canCreateSkillSpy.mockRestore();
}
});
+
+ it('resolves model-spec skill names through deployment-aware skill methods', async () => {
+ const deploymentSkillId = new mongoose.Types.ObjectId();
+ await AclEntry.create({
+ principalType: PrincipalType.USER,
+ principalId: testUser._id,
+ principalModel: PrincipalModel.USER,
+ resourceType: ResourceType.SKILL,
+ resourceId: new mongoose.Types.ObjectId(),
+ permBits: PermissionBits.VIEW,
+ grantedBy: testUser._id,
+ });
+ const endpointOption = makeEndpointOption();
+ endpointOption.spec = 'spec-deployment-skill';
+ endpointOption.agent = Promise.resolve({
+ id: Constants.EPHEMERAL_AGENT_ID,
+ name: 'Ephemeral Primary',
+ provider: 'openai',
+ model: 'gpt-4',
+ tools: [],
+ });
+ mockInitializeAgent.mockResolvedValue(makePrimaryConfig([]));
+ const req = makeReq();
+ req.config.endpoints.agents = { capabilities: ['skills'] };
+ req.config.modelSpecs = {
+ list: [{ name: 'spec-deployment-skill', skills: ['deployment-skill'] }],
+ };
+ const getSkillByNameSpy = jest.spyOn(getSkillDbMethods(), 'getSkillByName').mockResolvedValue({
+ _id: deploymentSkillId,
+ name: 'deployment-skill',
+ source: 'deployment',
+ });
+ const canCreateSkillSpy = jest
+ .spyOn(getSkillToolDeps(), 'canCreateSkill')
+ .mockResolvedValue(false);
+
+ try {
+ await initializeClient({
+ req,
+ res: {},
+ signal: new AbortController().signal,
+ endpointOption,
+ });
+
+ expect(getSkillByNameSpy).toHaveBeenCalledWith(
+ 'deployment-skill',
+ expect.any(Array),
+ expect.any(Object),
+ );
+ const initializeParams = mockInitializeAgent.mock.calls[0][0];
+ expect(initializeParams.agent.skills_enabled).toBe(true);
+ expect(initializeParams.agent.skills).toEqual([deploymentSkillId.toString()]);
+ } finally {
+ getSkillByNameSpy.mockRestore();
+ canCreateSkillSpy.mockRestore();
+ }
+ });
});
describe('initializeClient — subagent loading', () => {
diff --git a/client/src/components/Chat/Input/SkillsCommand.tsx b/client/src/components/Chat/Input/SkillsCommand.tsx
index 9105c780a3..f204acf714 100644
--- a/client/src/components/Chat/Input/SkillsCommand.tsx
+++ b/client/src/components/Chat/Input/SkillsCommand.tsx
@@ -7,10 +7,10 @@ import type { TSkillSummary } from 'librechat-data-provider';
import type { MentionOption } from '~/common';
import useInitPopoverInput from '~/hooks/Input/useInitPopoverInput';
import { useLocalize, useSkillActiveState } from '~/hooks';
-import { useAgentsMapContext } from '~/Providers';
import { useSkillsInfiniteQuery } from '~/data-provider';
-import { isEphemeralAgent } from '~/common';
+import { useAgentsMapContext } from '~/Providers';
import { ephemeralAgentByConvoId } from '~/store';
+import { isEphemeralAgent } from '~/common';
import { removeCharIfLast } from '~/utils';
import MentionItem from './MentionItem';
import store from '~/store';
@@ -50,7 +50,7 @@ export function filterSkillsForPopover(
skills: TSkillSummary[],
ctx: {
agentSkillIds: string[] | null | undefined;
- isActive: (skill: Pick<TSkillSummary, '_id' | 'author'>) => boolean;
+ isActive: (skill: Pick<TSkillSummary, '_id' | 'author' | 'source'>) => boolean;
},
): TSkillSummary[] {
const { agentSkillIds, isActive } = ctx;
@@ -128,21 +128,10 @@ function SkillsCommandContent({
const { data, isLoading, isError, fetchNextPage, hasNextPage, isFetchingNextPage } =
useSkillsInfiniteQuery({ limit: 50 });
- /* Sticky circuit breaker: once any page request fails, stop auto-fetching
- for the lifetime of the popover so a transient API error does not turn
- into an unbounded retry loop (isError can flip back to false on the
- next attempt, which would otherwise re-arm the auto-fetch effect). */
- const paginationBlockedRef = useRef(false);
- useEffect(() => {
- if (isError) {
- paginationBlockedRef.current = true;
- }
- }, [isError]);
-
/* Auto-fetch all pages so client-side search covers the full catalog,
not just the first page. The skills API is server-side capped. */
useEffect(() => {
- if (paginationBlockedRef.current || isError) {
+ if (isError) {
return;
}
if (hasNextPage && !isFetchingNextPage) {
diff --git a/client/src/components/Chat/Input/__tests__/SkillsCommand.spec.tsx b/client/src/components/Chat/Input/__tests__/SkillsCommand.spec.tsx
index ecafb84586..a4951798dd 100644
--- a/client/src/components/Chat/Input/__tests__/SkillsCommand.spec.tsx
+++ b/client/src/components/Chat/Input/__tests__/SkillsCommand.spec.tsx
@@ -435,6 +435,36 @@ describe('SkillsCommand', () => {
expect(screen.queryByRole('button', { name: /Brand Guidelines/i })).toBeNull();
expect(screen.getByRole('button', { name: /Style Guide/i })).toBeInTheDocument();
});
+
+ it('resumes catalog pagination after an external refetch clears an error', () => {
+ const fetchNextPage = jest.fn();
+ mockUseSkillsInfiniteQuery.mockReturnValue({
+ data: skillsResponse,
+ isLoading: false,
+ isError: true,
+ fetchNextPage,
+ hasNextPage: true,
+ isFetchingNextPage: false,
+ });
+
+ const textAreaRef = makeTextarea('$');
+ const { rerender } = render(
+ <SkillsCommand index={0} textAreaRef={textAreaRef} conversationId={CONVO_ID} />,
+ );
+ expect(fetchNextPage).not.toHaveBeenCalled();
+
+ mockUseSkillsInfiniteQuery.mockReturnValue({
+ data: skillsResponse,
+ isLoading: false,
+ isError: false,
+ fetchNextPage,
+ hasNextPage: true,
+ isFetchingNextPage: false,
+ });
+ rerender(<SkillsCommand index={1} textAreaRef={textAreaRef} conversationId={CONVO_ID} />);
+
+ expect(fetchNextPage).toHaveBeenCalledTimes(1);
+ });
});
describe('filterSkillsForPopover', () => {
diff --git a/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx b/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
index 08b934f580..29833e515f 100644
--- a/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState, useCallback } from 'react';
+import { useMemo, useState, useCallback, useEffect } from 'react';
import { Plus, Search } from 'lucide-react';
import { useFormContext, useWatch } from 'react-hook-form';
import { PermissionTypes, Permissions } from 'librechat-data-provider';
@@ -11,7 +11,7 @@ import {
OGDialogContent,
OGDialogDescription,
} from '@librechat/client';
-import type { TSkill } from 'librechat-data-provider';
+import type { TSkill, TSkillSummary } from 'librechat-data-provider';
import type { TranslationKeys } from '~/hooks/useLocalize';
import type { CategoryOption } from './CategoryFilter';
import type { AgentItem } from './items/types';
@@ -19,8 +19,8 @@ import type { AgentForm } from '~/common';
import { useLocalize, useHasAccess, useAuthContext, useToolFavorites } from '~/hooks';
import { CreateSkillDialog } from '~/components/Skills/dialogs';
import { skillsEnabledTransition } from './items/mutations';
+import { useSkillsInfiniteQuery } from '~/data-provider';
import MarketplaceCatalog from './MarketplaceCatalog';
-import { useListSkillsQuery } from '~/data-provider';
import { CategoryIcon } from '~/components/Prompts';
import { buildSkillItems } from './items/catalog';
import ItemDialog from './ItemDialog/ItemDialog';
@@ -55,12 +55,30 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
permissionType: PermissionTypes.SKILLS,
permission: Permissions.CREATE,
});
- const { data: skillsData, isLoading: isLoadingSkills } = useListSkillsQuery(
- { limit: 100 },
- { enabled: hasSkillsAccess },
- );
+ const {
+ data: skillsData,
+ isLoading: isLoadingSkills,
+ isError: isSkillsError,
+ fetchNextPage,
+ refetch: refetchSkills,
+ hasNextPage,
+ isFetchingNextPage,
+ } = useSkillsInfiniteQuery({ limit: 100 }, { enabled: hasSkillsAccess });
const { favoriteKeys, toggle: toggleFavorite } = useToolFavorites();
+ useEffect(() => {
+ if (isSkillsError) {
+ return;
+ }
+ if (hasNextPage && !isFetchingNextPage) {
+ fetchNextPage();
+ }
+ }, [hasNextPage, isFetchingNextPage, isSkillsError, fetchNextPage]);
+
+ const handleRetrySkills = useCallback(() => {
+ void refetchSkills();
+ }, [refetchSkills]);
+
const skillsField = useWatch({ control, name: 'skills' });
const selectedIds = useMemo(
() => new Set(((skillsField ?? []) as string[]).map((id) => itemKey({ kind: 'skill', id }))),
@@ -73,10 +91,22 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
const [createOpen, setCreateOpen] = useState(false);
const [detailItem, setDetailItem] = useState<AgentItem | null>(null);
- const catalog = useMemo(
- () => buildSkillItems(skillsData?.skills ?? [], user?.id),
- [skillsData, user?.id],
- );
+ const skills = useMemo(() => {
+ const allSkills: TSkillSummary[] = [];
+ const seen = new Set<string>();
+ for (const page of skillsData?.pages ?? []) {
+ for (const skill of page.skills) {
+ if (seen.has(skill._id)) {
+ continue;
+ }
+ seen.add(skill._id);
+ allSkills.push(skill);
+ }
+ }
+ return allSkills;
+ }, [skillsData?.pages]);
+
+ const catalog = useMemo(() => buildSkillItems(skills, user?.id), [skills, user?.id]);
const categoryOptions = useMemo<CategoryOption[]>(() => {
const seen = new Set<string>();
@@ -210,13 +240,24 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
</div>
<div className="flex-1 overflow-y-auto px-6 py-4">
+ {isSkillsError && (
+ <div
+ role="alert"
+ className="mb-3 flex items-center justify-between gap-3 rounded-xl border border-border-medium px-3 py-2 text-sm text-text-secondary"
+ >
+ <span>{localize('com_ui_skills_load_error')}</span>
+ <Button type="button" variant="outline" onClick={handleRetrySkills}>
+ {localize('com_ui_retry')}
+ </Button>
+ </div>
+ )}
<MarketplaceCatalog
items={filtered}
selectedIds={selectedIds}
onToggle={handleToggle}
onConfigure={setDetailItem}
view={view}
- isLoadingSkills={isLoadingSkills}
+ isLoadingSkills={isLoadingSkills || isFetchingNextPage}
skillsInView={view !== 'mine'}
favoriteKeys={favoriteKeys}
onToggleFavorite={toggleFavorite}
diff --git a/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx b/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx
new file mode 100644
index 0000000000..bb0de03fac
--- /dev/null
+++ b/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx
@@ -0,0 +1,249 @@
+import React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { TSkillSummary } from 'librechat-data-provider';
+import SkillsDialog from '../SkillsDialog';
+
+const mockFetchNextPage = jest.fn();
+const mockRefetch = jest.fn();
+const mockUseListSkillsQuery = jest.fn();
+const mockUseSkillsInfiniteQuery = jest.fn();
+
+let mockInfiniteResult: {
+ data?: { pages: Array<{ skills: TSkillSummary[] }> };
+ isLoading: boolean;
+ isError: boolean;
+ fetchNextPage: jest.Mock;
+ refetch: jest.Mock;
+ hasNextPage: boolean;
+ isFetchingNextPage: boolean;
+};
+
+jest.mock('react-hook-form', () => ({
+ useFormContext: () => ({
+ control: {},
+ getValues: (name: string) => (name === 'skills' ? [] : false),
+ setValue: jest.fn(),
+ }),
+ useWatch: () => [],
+}));
+
+jest.mock('~/hooks', () => ({
+ useLocalize: () => (key: string) => {
+ const values: Record<string, string> = {
+ com_ui_skills: 'Skills',
+ com_ui_search_skills: 'Search skills...',
+ com_ui_skills_dialog_description: 'Browse and add skills to your agent.',
+ com_ui_skills_load_error: 'Failed to load skills',
+ com_ui_retry: 'Retry',
+ };
+ return values[key] ?? key;
+ },
+ useHasAccess: () => true,
+ useAuthContext: () => ({ user: { id: 'user-1' } }),
+ useToolFavorites: () => ({
+ favoriteKeys: new Set<string>(),
+ toggle: jest.fn(),
+ }),
+}));
+
+jest.mock('~/data-provider', () => ({
+ useListSkillsQuery: (...args: unknown[]) => mockUseListSkillsQuery(...args),
+ useSkillsInfiniteQuery: (...args: unknown[]) => mockUseSkillsInfiniteQuery(...args),
+}));
+
+jest.mock('~/components/Prompts', () => ({
+ CategoryIcon: () => <span aria-hidden="true" />,
+}));
+
+jest.mock('~/components/Skills/dialogs', () => ({
+ CreateSkillDialog: () => null,
+}));
+
+jest.mock('../CategoryFilter', () => ({
+ __esModule: true,
+ default: () => null,
+}));
+
+jest.mock('../ItemDialog/ItemDialog', () => ({
+ __esModule: true,
+ default: () => null,
+}));
+
+jest.mock('../MarketplaceCatalog', () => ({
+ __esModule: true,
+ default: ({
+ items,
+ ariaLabel,
+ }: {
+ items: Array<{ id: string; name: string }>;
+ ariaLabel: string;
+ }) => (
+ <ul aria-label={ariaLabel}>
+ {items.map((item) => (
+ <li key={item.id}>{item.name}</li>
+ ))}
+ </ul>
+ ),
+}));
+
+jest.mock('@librechat/client', () => ({
+ Button: ({ children, ...props }: React.ComponentProps<'button'>) => (
+ <button type="button" {...props}>
+ {children}
+ </button>
+ ),
+ Input: (props: React.ComponentProps<'input'>) => <input {...props} />,
+ Radio: () => null,
+ OGDialog: ({ open, children }: { open: boolean; children: React.ReactNode }) =>
+ open ? <div>{children}</div> : null,
+ OGDialogContent: ({ children }: { children: React.ReactNode }) => (
+ <div role="dialog">{children}</div>
+ ),
+ OGDialogTitle: ({ children }: { children: React.ReactNode }) => <h2>{children}</h2>,
+ OGDialogDescription: ({ children }: { children: React.ReactNode }) => <p>{children}</p>,
+}));
+
+function makeSkill(id: string, name: string): TSkillSummary {
+ return {
+ _id: id,
+ name,
+ description: `${name} description`,
+ author: 'user-1',
+ authorName: 'E2E User',
+ version: 1,
+ source: 'inline',
+ fileCount: 0,
+ createdAt: '2026-07-24T00:00:00.000Z',
+ updatedAt: '2026-07-24T00:00:00.000Z',
+ };
+}
+
+beforeEach(() => {
+ mockInfiniteResult = {
+ data: { pages: [{ skills: [makeSkill('first', 'first-skill')] }] },
+ isLoading: false,
+ isError: false,
+ fetchNextPage: mockFetchNextPage,
+ refetch: mockRefetch,
+ hasNextPage: true,
+ isFetchingNextPage: false,
+ };
+ mockFetchNextPage.mockReset();
+ mockRefetch.mockReset();
+ mockUseListSkillsQuery.mockReset();
+ mockUseListSkillsQuery.mockReturnValue({
+ data: { skills: [makeSkill('first', 'first-skill')] },
+ isLoading: false,
+ });
+ mockUseSkillsInfiniteQuery.mockReset();
+ mockUseSkillsInfiniteQuery.mockImplementation(() => mockInfiniteResult);
+});
+
+describe('SkillsDialog pagination', () => {
+ test('auto-fetches every page and stops after the final page', () => {
+ const { rerender } = render(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(mockUseSkillsInfiniteQuery).toHaveBeenCalledWith({ limit: 100 }, { enabled: true });
+ expect(mockFetchNextPage).toHaveBeenCalledTimes(1);
+
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ isFetchingNextPage: true,
+ };
+ rerender(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(mockFetchNextPage).toHaveBeenCalledTimes(1);
+
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ data: {
+ pages: [
+ { skills: [makeSkill('first', 'first-skill')] },
+ { skills: [makeSkill('second', 'second-skill')] },
+ ],
+ },
+ hasNextPage: true,
+ isFetchingNextPage: false,
+ };
+ rerender(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(mockFetchNextPage).toHaveBeenCalledTimes(2);
+ expect(screen.getByText('second-skill')).toBeInTheDocument();
+
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ isFetchingNextPage: true,
+ };
+ rerender(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(mockFetchNextPage).toHaveBeenCalledTimes(2);
+
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ data: {
+ pages: [
+ { skills: [makeSkill('first', 'first-skill')] },
+ { skills: [makeSkill('second', 'second-skill')] },
+ { skills: [makeSkill('third', 'third-skill')] },
+ ],
+ },
+ hasNextPage: false,
+ isFetchingNextPage: false,
+ };
+ rerender(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(screen.getByText('third-skill')).toBeInTheDocument();
+ expect(mockFetchNextPage).toHaveBeenCalledTimes(2);
+ });
+
+ test('flattens and de-duplicates every loaded page for discovery', () => {
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ data: {
+ pages: [
+ { skills: [makeSkill('first', 'first-skill')] },
+ {
+ skills: [makeSkill('first', 'first-skill'), makeSkill('off-page', 'off-page-skill')],
+ },
+ ],
+ },
+ hasNextPage: false,
+ };
+
+ render(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(screen.getAllByText('first-skill')).toHaveLength(1);
+ expect(screen.getByText('off-page-skill')).toBeInTheDocument();
+ });
+
+ test('shows a recoverable pagination error and retries on request', () => {
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ isError: true,
+ };
+ render(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+ expect(mockFetchNextPage).not.toHaveBeenCalled();
+ expect(screen.getByRole('alert')).toHaveTextContent('Failed to load skills');
+ fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
+ expect(mockRefetch).toHaveBeenCalledTimes(1);
+ });
+
+ test('resumes pagination after an external refetch clears the error', () => {
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ isError: true,
+ };
+ const { rerender } = render(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+ expect(mockFetchNextPage).not.toHaveBeenCalled();
+
+ mockInfiniteResult = {
+ ...mockInfiniteResult,
+ isError: false,
+ };
+ rerender(<SkillsDialog open onOpenChange={jest.fn()} agentId="agent-1" />);
+
+ expect(mockFetchNextPage).toHaveBeenCalledTimes(1);
+ expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+ });
+});
diff --git a/client/src/components/Skills/dialogs/CreateSkillDialog.tsx b/client/src/components/Skills/dialogs/CreateSkillDialog.tsx
index ac32a2f13e..c744233e8e 100644
--- a/client/src/components/Skills/dialogs/CreateSkillDialog.tsx
+++ b/client/src/components/Skills/dialogs/CreateSkillDialog.tsx
@@ -13,6 +13,7 @@ import {
SKILL_DESCRIPTION_MAX_LENGTH,
} from 'librechat-data-provider';
import type { TSkill } from 'librechat-data-provider';
+import type { FormEvent } from 'react';
import { useCreateSkillMutation } from '~/data-provider';
import { useLocalize } from '~/hooks';
import { cn } from '~/utils';
@@ -98,13 +99,23 @@ export default function CreateSkillDialog({
reset();
};
+ const handleFormSubmit = (event: FormEvent<HTMLFormElement>) => {
+ /**
+ * This dialog can be portaled from inside Agent Builder's form. React
+ * events still bubble through the component tree across a portal, so an
+ * unguarded submit also submits (and prematurely creates) the agent.
+ */
+ event.stopPropagation();
+ return handleSubmit(onSubmit)(event);
+ };
+
const submitDisabled = !isValid || isSubmitting || createSkill.isLoading;
return (
<OGDialog open={isOpen} onOpenChange={setIsOpen}>
<OGDialogContent className="w-11/12 max-w-5xl overflow-hidden" showCloseButton={false}>
<form
- onSubmit={handleSubmit(onSubmit)}
+ onSubmit={handleFormSubmit}
className="flex max-h-[80vh] min-w-0 flex-col gap-3 overflow-hidden p-1 sm:gap-4 sm:p-2"
>
<h2 className="text-lg font-bold text-text-primary">
diff --git a/client/src/components/Skills/dialogs/__tests__/CreateSkillDialog.spec.tsx b/client/src/components/Skills/dialogs/__tests__/CreateSkillDialog.spec.tsx
new file mode 100644
index 0000000000..4c2ca3ac4f
--- /dev/null
+++ b/client/src/components/Skills/dialogs/__tests__/CreateSkillDialog.spec.tsx
@@ -0,0 +1,111 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import type { FormEvent, ReactNode } from 'react';
+import CreateSkillDialog from '../CreateSkillDialog';
+
+const mockMutate = jest.fn();
+const mockNavigate = jest.fn();
+const mockSetIsOpen = jest.fn();
+const mockShowToast = jest.fn();
+
+jest.mock('react-router-dom', () => ({
+ ...jest.requireActual('react-router-dom'),
+ useNavigate: () => mockNavigate,
+}));
+
+jest.mock(
+ '@librechat/client',
+ () => {
+ const React = jest.requireActual<typeof import('react')>('react');
+ const ReactDOM = jest.requireActual<typeof import('react-dom')>('react-dom');
+ return {
+ Button: ({
+ children,
+ variant: _variant,
+ ...props
+ }: React.ButtonHTMLAttributes<HTMLButtonElement> & { variant?: string }) =>
+ React.createElement('button', props, children),
+ OGDialog: ({ open, children }: { open: boolean; children: ReactNode }) =>
+ open ? React.createElement(React.Fragment, null, children) : null,
+ OGDialogContent: ({ children }: { children: ReactNode }) =>
+ ReactDOM.createPortal(React.createElement('div', null, children), globalThis.document.body),
+ TextareaAutosize: React.forwardRef<
+ HTMLTextAreaElement,
+ React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+ minRows?: number;
+ maxRows?: number;
+ }
+ >(({ minRows: _minRows, maxRows: _maxRows, ...props }, ref) =>
+ React.createElement('textarea', { ...props, ref }),
+ ),
+ useToastContext: () => ({
+ showToast: mockShowToast,
+ }),
+ };
+ },
+ { virtual: true },
+);
+
+jest.mock('~/data-provider', () => ({
+ useCreateSkillMutation: () => ({
+ mutate: mockMutate,
+ isLoading: false,
+ }),
+}));
+
+jest.mock('~/hooks', () => ({
+ useLocalize: () => (key: string) => {
+ const translations: Record<string, string> = {
+ com_ui_name: 'Name',
+ com_ui_description: 'Description',
+ com_ui_skill_instructions: 'Instructions',
+ com_ui_cancel: 'Cancel',
+ com_ui_create: 'Create',
+ };
+ return translations[key] ?? key;
+ },
+}));
+
+jest.mock('~/utils', () => ({
+ cn: (...classes: Array<string | false | null | undefined>) => classes.filter(Boolean).join(' '),
+}));
+
+describe('CreateSkillDialog', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('does not submit an ancestor form when rendered through a portal', async () => {
+ const handleAgentSubmit = jest.fn((event: FormEvent<HTMLFormElement>) =>
+ event.preventDefault(),
+ );
+
+ render(
+ <form onSubmit={handleAgentSubmit}>
+ <CreateSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />
+ </form>,
+ );
+
+ fireEvent.change(screen.getByLabelText('Name'), {
+ target: { value: 'portal-skill' },
+ });
+ fireEvent.change(screen.getByLabelText('Description'), {
+ target: { value: 'A skill created from Agent Builder' },
+ });
+ fireEvent.change(screen.getByLabelText('Instructions'), {
+ target: { value: 'Apply the portal skill.' },
+ });
+
+ const createButton = screen.getByRole('button', { name: 'Create' });
+ await waitFor(() => expect(createButton).toBeEnabled());
+ fireEvent.click(createButton);
+
+ await waitFor(() =>
+ expect(mockMutate).toHaveBeenCalledWith({
+ name: 'portal-skill',
+ description: 'A skill created from Agent Builder',
+ body: 'Apply the portal skill.',
+ }),
+ );
+ expect(handleAgentSubmit).not.toHaveBeenCalled();
+ });
+});
diff --git a/client/src/data-provider/Skills/__tests__/mutations.spec.tsx b/client/src/data-provider/Skills/__tests__/mutations.spec.tsx
new file mode 100644
index 0000000000..4bd782ba3d
--- /dev/null
+++ b/client/src/data-provider/Skills/__tests__/mutations.spec.tsx
@@ -0,0 +1,142 @@
+import React from 'react';
+import { QueryKeys } from 'librechat-data-provider';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TSkill, TSkillListResponse } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import { useCreateSkillMutation } from '../mutations';
+import { useSkillsInfiniteQuery } from '../queries';
+
+const mockCreateSkill = jest.fn();
+const mockListSkills = jest.fn();
+
+jest.mock('librechat-data-provider', () => {
+ const actual = jest.requireActual('librechat-data-provider');
+ return {
+ ...actual,
+ dataService: {
+ ...actual.dataService,
+ createSkill: (...args: unknown[]) => mockCreateSkill(...args),
+ listSkills: (...args: unknown[]) => mockListSkills(...args),
+ },
+ };
+});
+
+function makeSkill(id: string, name: string): TSkill {
+ return {
+ _id: id,
+ name,
+ description: `${name} description`,
+ body: `# ${name}`,
+ author: 'user-1',
+ authorName: 'E2E User',
+ version: 1,
+ source: 'inline',
+ fileCount: 0,
+ createdAt: '2026-07-24T00:00:00.000Z',
+ updatedAt: '2026-07-24T00:00:00.000Z',
+ } as TSkill;
+}
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((resolvePromise) => {
+ resolve = resolvePromise;
+ });
+ return { promise, resolve };
+}
+
+describe('skill creation cache updates', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('keeps a created skill when a stale next-page request finishes afterward', async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: {
+ queries: { retry: false },
+ mutations: { retry: false },
+ },
+ });
+ const firstSkill = makeSkill('first-id', 'first-skill');
+ const createdSkill = makeSkill('created-id', 'created-skill');
+ const stalePage = deferred<TSkillListResponse>();
+ const firstPage: TSkillListResponse = {
+ skills: [firstSkill],
+ has_more: true,
+ after: 'cursor-1',
+ };
+ const freshPage: TSkillListResponse = {
+ skills: [createdSkill, firstSkill],
+ has_more: false,
+ after: null,
+ };
+ const queryKey = [QueryKeys.skills, 'infinite', '', '', 100];
+ queryClient.setQueryData(queryKey, {
+ pages: [firstPage],
+ pageParams: [undefined],
+ });
+ mockCreateSkill.mockResolvedValue(createdSkill);
+ mockListSkills.mockImplementation(({ cursor }: { cursor?: string }) =>
+ cursor === 'cursor-1' ? stalePage.promise : Promise.resolve(freshPage),
+ );
+ const cancelQueries = jest.spyOn(queryClient, 'cancelQueries');
+ const wrapper = ({ children }: { children: ReactNode }) => (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ );
+
+ const { result } = renderHook(
+ () => ({
+ list: useSkillsInfiniteQuery({ limit: 100 }),
+ create: useCreateSkillMutation(),
+ }),
+ { wrapper },
+ );
+
+ let staleRequest: Promise<unknown>;
+ act(() => {
+ staleRequest = result.current.list.fetchNextPage();
+ });
+ await waitFor(() =>
+ expect(mockListSkills).toHaveBeenCalledWith(
+ expect.objectContaining({ cursor: 'cursor-1', limit: 100 }),
+ ),
+ );
+
+ await act(async () => {
+ await result.current.create.mutateAsync({
+ name: createdSkill.name,
+ description: createdSkill.description,
+ body: createdSkill.body,
+ });
+ });
+
+ expect(cancelQueries).toHaveBeenCalledWith([QueryKeys.skills]);
+ await waitFor(() =>
+ expect(
+ queryClient
+ .getQueryData<{ pages: TSkillListResponse[] }>(queryKey)
+ ?.pages.flatMap((page) => page.skills)
+ .map((skill) => skill._id),
+ ).toContain(createdSkill._id),
+ );
+
+ stalePage.resolve({
+ skills: [makeSkill('second-id', 'second-skill')],
+ has_more: false,
+ after: null,
+ });
+ await act(async () => {
+ await Promise.allSettled([staleRequest]);
+ });
+
+ expect(
+ queryClient
+ .getQueryData<{ pages: TSkillListResponse[] }>(queryKey)
+ ?.pages.flatMap((page) => page.skills)
+ .map((skill) => skill._id),
+ ).toContain(createdSkill._id);
+
+ queryClient.clear();
+ });
+});
diff --git a/client/src/data-provider/Skills/mutations.ts b/client/src/data-provider/Skills/mutations.ts
index ff0b6c1876..5d84e9438c 100644
--- a/client/src/data-provider/Skills/mutations.ts
+++ b/client/src/data-provider/Skills/mutations.ts
@@ -1,6 +1,5 @@
-import { useMutation, useQueryClient } from '@tanstack/react-query';
import { QueryKeys, dataService } from 'librechat-data-provider';
-import type { InfiniteData, QueryKey, UseMutationResult } from '@tanstack/react-query';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
import type {
TSkill,
TSkillFile,
@@ -21,6 +20,7 @@ import type {
ImportSkillOptions,
DeleteSkillFileOptions,
} from 'librechat-data-provider';
+import type { InfiniteData, QueryKey, UseMutationResult } from '@tanstack/react-query';
function isInfiniteSkillData(
data: TSkillListResponse | InfiniteData<TSkillListResponse>,
@@ -49,14 +49,21 @@ function addSkillToCachedLists(
queryClient.setQueriesData<TSkillCacheEntry>([QueryKeys.skills], (data) => {
if (!data) return data;
if (isInfiniteSkillData(data)) {
+ const pages = data.pages.map((page) => ({
+ ...page,
+ skills: page.skills.filter((existing) => existing._id !== skill._id),
+ }));
return {
...data,
- pages: data.pages.map((page, i) =>
+ pages: pages.map((page, i) =>
i === 0 ? { ...page, skills: [skill, ...page.skills] } : page,
),
};
}
- return { ...data, skills: [skill, ...data.skills] };
+ return {
+ ...data,
+ skills: [skill, ...data.skills.filter((existing) => existing._id !== skill._id)],
+ };
});
}
@@ -119,9 +126,16 @@ export const useCreateSkillMutation = (
return useMutation({
mutationFn: (payload: TCreateSkill) => dataService.createSkill(payload),
...rest,
- onSuccess: (skill, variables, context) => {
+ onSuccess: async (skill, variables, context) => {
+ /**
+ * An infinite skill query may have captured its pre-create pages before
+ * this mutation completed. Cancel it before the cache write so a late
+ * cursor response cannot replace the newly-created row.
+ */
+ await queryClient.cancelQueries([QueryKeys.skills]);
queryClient.setQueryData<TSkill>([QueryKeys.skill, skill._id], skill);
addSkillToCachedLists(queryClient, skill);
+ void queryClient.invalidateQueries([QueryKeys.skills]);
if (onSuccess) onSuccess(skill, variables, context);
},
});
@@ -139,9 +153,11 @@ export const useImportSkillMutation = (
return useMutation({
mutationFn: (formData: FormData) => dataService.importSkill(formData),
...rest,
- onSuccess: (skill, variables, context) => {
+ onSuccess: async (skill, variables, context) => {
+ await queryClient.cancelQueries([QueryKeys.skills]);
queryClient.setQueryData<TSkill>([QueryKeys.skill, skill._id], skill);
addSkillToCachedLists(queryClient, skill);
+ void queryClient.invalidateQueries([QueryKeys.skills]);
if (onSuccess) onSuccess(skill, variables, context);
},
});
diff --git a/client/src/hooks/Skills/__tests__/useSkillActiveState.test.ts b/client/src/hooks/Skills/__tests__/useSkillActiveState.test.ts
new file mode 100644
index 0000000000..b7bdf05cae
--- /dev/null
+++ b/client/src/hooks/Skills/__tests__/useSkillActiveState.test.ts
@@ -0,0 +1,25 @@
+import { resolveSkillDefaultActive } from '../useSkillActiveState';
+
+describe('resolveSkillDefaultActive', () => {
+ test('activates deployment skills for every user by default', () => {
+ expect(
+ resolveSkillDefaultActive(
+ { author: 'deployment-registry', source: 'deployment' },
+ 'user-1',
+ false,
+ ),
+ ).toBe(true);
+ });
+
+ test('activates owned inline skills by default', () => {
+ expect(resolveSkillDefaultActive({ author: 'user-1', source: 'inline' }, 'user-1', false)).toBe(
+ true,
+ );
+ });
+
+ test('uses the shared-skill configuration for non-owned inline skills', () => {
+ const skill = { author: 'user-2', source: 'inline' } as const;
+ expect(resolveSkillDefaultActive(skill, 'user-1', false)).toBe(false);
+ expect(resolveSkillDefaultActive(skill, 'user-1', true)).toBe(true);
+ });
+});
diff --git a/client/src/hooks/Skills/useSkillActiveState.ts b/client/src/hooks/Skills/useSkillActiveState.ts
index 85052eda87..4026af6c31 100644
--- a/client/src/hooks/Skills/useSkillActiveState.ts
+++ b/client/src/hooks/Skills/useSkillActiveState.ts
@@ -1,8 +1,8 @@
import { useCallback, useEffect, useMemo } from 'react';
-import { useQueryClient } from '@tanstack/react-query';
import { QueryKeys } from 'librechat-data-provider';
import { useToastContext } from '@librechat/client';
-import type { TSkillStatesResponse } from 'librechat-data-provider';
+import { useQueryClient } from '@tanstack/react-query';
+import type { TSkillStatesResponse, TSkillSummary } from 'librechat-data-provider';
import {
useGetSkillStatesQuery,
useUpdateSkillStatesMutation,
@@ -12,6 +12,7 @@ import { useAuthContext, useLocalize } from '~/hooks';
import { logger } from '~/utils';
const EMPTY_STATES: TSkillStatesResponse = {};
+type SkillActiveTarget = Pick<TSkillSummary, '_id' | 'author' | 'source'>;
interface WriteQueue {
pending: TSkillStatesResponse | null;
@@ -65,19 +66,28 @@ function getWriteQueue(userId: string): WriteQueue {
/**
* Resolves the default active state for a skill the user has never toggled.
*
+ * - Deployment skills default to **active** for every user.
* - Owned skills (author === currentUser) default to **active**.
* - Shared skills default to the `defaultActiveOnShare` config value (default `false`).
*/
-function resolveDefault(author: string, userId: string, defaultActiveOnShare: boolean): boolean {
- return author === userId ? true : defaultActiveOnShare;
+export function resolveSkillDefaultActive(
+ skill: Pick<SkillActiveTarget, 'author' | 'source'>,
+ userId: string,
+ defaultActiveOnShare: boolean,
+): boolean {
+ if (skill.source === 'deployment' || skill.author === userId) {
+ return true;
+ }
+ return defaultActiveOnShare;
}
/**
* Hook for managing per-user skill active/inactive state.
*
* The `skillStates` map stores explicit overrides (`{ [skillId]: boolean }`).
- * Skills absent from the map use the ownership-based default: owned -> active,
- * shared -> `defaultActiveOnShare` from the interface config. Toggles that
+ * Skills absent from the map use the source/ownership default: deployment and
+ * owned skills -> active, shared skills -> `defaultActiveOnShare` from the
+ * interface config. Toggles that
* land on the resolved default remove the key from the map rather than
* persisting a redundant entry, keeping `skillStates` strictly an exceptions
* list (otherwise rapid round-trip toggles would exhaust the 200-entry cap).
@@ -165,18 +175,18 @@ export default function useSkillActiveState() {
}, [userId, updateMutation, showToast, localize]);
const isActive = useCallback(
- (skill: { _id: string; author: string }): boolean => {
+ (skill: SkillActiveTarget): boolean => {
const override = skillStates[skill._id];
if (override !== undefined) {
return override;
}
- return resolveDefault(skill.author, userId, defaultActiveOnShare);
+ return resolveSkillDefaultActive(skill, userId, defaultActiveOnShare);
},
[skillStates, userId, defaultActiveOnShare],
);
const toggle = useCallback(
- (skill: { _id: string; author: string }) => {
+ (skill: SkillActiveTarget) => {
if (!canToggle || !userId) {
return;
}
@@ -184,7 +194,7 @@ export default function useSkillActiveState() {
const cached =
queryClient.getQueryData<TSkillStatesResponse>([QueryKeys.skillStates]) ?? EMPTY_STATES;
const baseline = queue.pending ?? cached;
- const defaultValue = resolveDefault(skill.author, userId, defaultActiveOnShare);
+ const defaultValue = resolveSkillDefaultActive(skill, userId, defaultActiveOnShare);
const override = baseline[skill._id];
const currentActive = override !== undefined ? override : defaultValue;
const nextValue = !currentActive;
diff --git a/e2e/config/librechat.e2e.yaml b/e2e/config/librechat.e2e.yaml
index 4edeca9c0a..3a8e287f94 100644
--- a/e2e/config/librechat.e2e.yaml
+++ b/e2e/config/librechat.e2e.yaml
@@ -145,6 +145,7 @@ modelSpecs:
model: 'mock-model-a'
skills:
- 'e2e-model-spec-allowed'
+ - 'e2e-deployment-skill'
- 'e2e-model-spec-missing'
- 'e2e-model-spec-inaccessible'
diff --git a/e2e/setup/fake-model.js b/e2e/setup/fake-model.js
index f008c79baf..d432e687d0 100644
--- a/e2e/setup/fake-model.js
+++ b/e2e/setup/fake-model.js
@@ -18,7 +18,9 @@ const CHUNK_DELAY_MS = Number(process.env.MOCK_LLM_CHUNK_DELAY_MS) || 10;
const CREATE_SKILL_MARKER = 'E2E_CREATE_SKILL:';
const EDIT_SKILL_MARKER = 'E2E_EDIT_SKILL:';
-const ASSERT_MODEL_SPEC_SKILLS_MARKER = 'E2E_ASSERT_MODEL_SPEC_SKILLS';
+const ASSERT_SKILLS_MARKER = 'E2E_ASSERT_SKILLS:';
+const ASSERT_MANUAL_SKILL_MARKER = 'E2E_ASSERT_MANUAL_SKILL:';
+const INVOKE_SKILL_MARKER = 'E2E_INVOKE_SKILL:';
const ASSERT_PROVIDER_FILE_MARKER = 'E2E_ASSERT_PROVIDER_FILE:';
const ASSERT_AGENT_CONTEXT_MARKER = 'E2E_ASSERT_AGENT_CONTEXT:';
const ASSERT_QUOTE_MARKER = 'E2E_ASSERT_QUOTE:';
@@ -34,7 +36,9 @@ const BACKGROUND_DISPATCH_MARKER = 'E2E_BACKGROUND_DISPATCH:';
const BACKGROUND_COLLECT_MARKER = 'E2E_BACKGROUND_COLLECT:';
const CREATE_FILE_AUTHORING_FINAL_TEXT = 'E2E file authoring complete';
const EDIT_FILE_AUTHORING_FINAL_TEXT = 'E2E file edit complete';
-const MODEL_SPEC_SKILL_ASSERTION_FINAL_TEXT = 'E2E model spec skill assertion passed';
+const SKILL_ASSERTION_FINAL_TEXT = 'E2E skill assertion passed';
+const MANUAL_SKILL_ASSERTION_FINAL_TEXT = 'E2E manual skill assertion passed';
+const SKILL_TOOL_ASSERTION_FINAL_TEXT = 'E2E skill tool assertion passed';
const PROVIDER_FILE_ASSERTION_FINAL_TEXT = 'E2E provider file assertion passed';
const AGENT_CONTEXT_ASSERTION_FINAL_TEXT = 'E2E agent context assertion passed';
const QUOTE_ASSERTION_FINAL_TEXT = 'E2E quote assertion passed';
@@ -55,9 +59,9 @@ const CHECK_BACKGROUND_TASK_TOOL_NAME = 'check_background_task';
const BACKGROUND_DISPATCH_TOOL_CALL_ID = 'call_e2e_background_dispatch';
const BACKGROUND_COLLECT_TOOL_CALL_ID = 'call_e2e_background_collect';
const MODEL_SPEC_ACCESSIBLE_SKILL = 'e2e-model-spec-allowed';
-const MODEL_SPEC_MISSING_SKILL = 'e2e-model-spec-missing';
-const MODEL_SPEC_INACCESSIBLE_SKILL = 'e2e-model-spec-inaccessible';
+const DEPLOYMENT_SKILL_NAME = 'e2e-deployment-skill';
const ALWAYS_APPLY_BODY_MARKER = 'E2E_ALWAYS_APPLY_BODY_MARKER';
+const DEPLOYMENT_SKILL_BODY_MARKER = 'E2E deployment skill loaded through Playwright';
const SKILL_DESCRIPTION =
'Use this skill to verify LibreChat skill file authoring in mock end-to-end tests.';
const EDITED_SKILL_DESCRIPTION =
@@ -165,13 +169,30 @@ function collectToolNames(agents) {
return names;
}
-function collectAdditionalInstructions(agents) {
- return (agents ?? [])
- .map((agent) =>
- typeof agent?.additional_instructions === 'string' ? agent.additional_instructions : '',
- )
- .filter(Boolean)
- .join('\n');
+async function getStreamAgentView({ graph, messages, options, runManager }) {
+ let agentId = runManager?.metadata?.agentId ?? options?.metadata?.agentId;
+ let agentContext;
+ if (typeof agentId === 'string') {
+ agentContext = graph?.agentContexts?.get(agentId);
+ } else if (graph?.agentContexts?.size === 1) {
+ [agentId, agentContext] = graph.agentContexts.entries().next().value;
+ }
+ /**
+ * Graph.attemptInvoke intentionally sends test override models the pruned
+ * messages directly, bypassing the production model's systemRunnable pipe.
+ * Apply that agent's runnable here so assertions inspect the same complete
+ * prompt (system catalog plus messages) that a real provider receives.
+ */
+ const systemRunnable = agentContext?.systemRunnable;
+ const promptMessages =
+ systemRunnable && typeof systemRunnable.invoke === 'function'
+ ? await systemRunnable.invoke(messages)
+ : messages;
+ return {
+ agentId,
+ messages: promptMessages,
+ toolNames: collectToolNames(agentContext ? [agentContext] : []),
+ };
}
function collectPromptText(value, parts = []) {
@@ -443,7 +464,7 @@ class UsageEmittingFakeChatModel extends FakeChatModel {
async *_streamResponseChunks(messages, options, runManager) {
let outputChars = 0;
- const dynamicResponse = this.resolveOnStream?.(messages);
+ const dynamicResponse = await this.resolveOnStream?.(messages, options, runManager);
const chunkStream = dynamicResponse
? this.streamDynamicResponseChunks({
responses: dynamicResponse.responses,
@@ -502,45 +523,208 @@ function overrideModel({ graph, responses, sleep, toolCalls, thrownError, resolv
});
}
-function modelSpecSkillAssertionResponses({ agents, messages, toolNames }) {
+function parseSkillAssertion(text, agentId) {
+ const markerValue = getMarkerValue(text, ASSERT_SKILLS_MARKER);
+ const sections = markerValue
+ .split(';')
+ .map((section) => section.trim())
+ .filter(Boolean);
+ const isAgentScoped = sections.some((section) => section.includes('='));
+ let entriesValue = markerValue;
+ if (isAgentScoped) {
+ // Parallel agents receive a per-run `____N` suffix while the request and
+ // persisted Agent Builder state retain the stable agent id.
+ const persistedAgentId =
+ typeof agentId === 'string' ? agentId.replace(/____\d+$/, '') : agentId;
+ const prefixes = [`${agentId}=`, `${persistedAgentId}=`];
+ const scopedSection = sections.find((section) =>
+ prefixes.some((prefix) => section.startsWith(prefix)),
+ );
+ if (!scopedSection) {
+ return {
+ required: [],
+ requiredBodies: [],
+ forbidden: [],
+ error: `no skill assertion was configured for agent ${agentId ?? 'unknown'}`,
+ };
+ }
+ const prefix = prefixes.find((candidate) => scopedSection.startsWith(candidate));
+ entriesValue = scopedSection.slice(prefix.length);
+ }
+
+ const entries = entriesValue
+ .split(',')
+ .map((entry) => entry.trim())
+ .filter(Boolean);
+ return entries.reduce(
+ (assertion, entry) => {
+ if (entry.startsWith('!')) {
+ const name = entry.slice(1);
+ if (name) {
+ assertion.forbidden.push(name);
+ }
+ return assertion;
+ }
+ if (entry.startsWith('*')) {
+ const name = entry.slice(1);
+ if (name) {
+ assertion.required.push(name);
+ assertion.requiredBodies.push(name);
+ }
+ return assertion;
+ }
+ assertion.required.push(entry);
+ return assertion;
+ },
+ { required: [], requiredBodies: [], forbidden: [], error: undefined },
+ );
+}
+
+function escapeRegExp(value) {
+ return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function promptHasSkillCatalogEntry(promptText, skillName) {
+ if (!promptText.includes('## Available Skills')) {
+ return false;
+ }
+ return new RegExp(`(?:^|\\n)- ${escapeRegExp(skillName)}(?::|\\s*(?:\\n|$))`, 'm').test(
+ promptText,
+ );
+}
+
+function expectedSkillBodyMarker(skillName) {
+ if (skillName === MODEL_SPEC_ACCESSIBLE_SKILL) {
+ return ALWAYS_APPLY_BODY_MARKER;
+ }
+ if (skillName === DEPLOYMENT_SKILL_NAME) {
+ return DEPLOYMENT_SKILL_BODY_MARKER;
+ }
+ return `# ${skillName}`;
+}
+
+function skillAssertionResponses({ messages, assertion, toolNames }) {
const failures = [];
- const additionalInstructions = collectAdditionalInstructions(agents);
+ if (assertion.error) {
+ failures.push(assertion.error);
+ }
+ const promptText = collectPromptText(messages).join('\n');
const skillPrimeMessages = collectSkillPrimeMessages(messages);
- const alwaysApplyPrime = skillPrimeMessages.find(
- (message) => message.name === MODEL_SPEC_ACCESSIBLE_SKILL && message.trigger === 'always-apply',
- );
- if (!toolNames.has(SKILL_TOOL_NAME)) {
+ if (assertion.required.length > 0 && !toolNames.has(SKILL_TOOL_NAME)) {
failures.push(`${SKILL_TOOL_NAME} tool was not advertised`);
}
- if (!additionalInstructions.includes(MODEL_SPEC_ACCESSIBLE_SKILL)) {
- failures.push(`${MODEL_SPEC_ACCESSIBLE_SKILL} was not present in the model-visible catalog`);
+ if (assertion.required.length === 0 && toolNames.has(SKILL_TOOL_NAME)) {
+ failures.push(`${SKILL_TOOL_NAME} tool was unexpectedly advertised`);
}
- if (additionalInstructions.includes(MODEL_SPEC_MISSING_SKILL)) {
- failures.push(`${MODEL_SPEC_MISSING_SKILL} leaked into the model-visible catalog`);
+ for (const name of assertion.required) {
+ if (!promptHasSkillCatalogEntry(promptText, name)) {
+ failures.push(`${name} was not present in the model-visible catalog`);
+ }
}
- if (additionalInstructions.includes(MODEL_SPEC_INACCESSIBLE_SKILL)) {
- failures.push(`${MODEL_SPEC_INACCESSIBLE_SKILL} leaked into the model-visible catalog`);
+ for (const name of assertion.requiredBodies) {
+ const expectedMarker = expectedSkillBodyMarker(name);
+ const taggedBody = skillPrimeMessages.find((message) => message.name === name);
+ if (!taggedBody?.content.includes(expectedMarker)) {
+ failures.push(`${name} body was missing its expected marker "${expectedMarker}"`);
+ }
}
- if (!alwaysApplyPrime) {
- failures.push(`${MODEL_SPEC_ACCESSIBLE_SKILL} was not always-apply primed`);
- } else if (!alwaysApplyPrime.content.includes(ALWAYS_APPLY_BODY_MARKER)) {
- failures.push(`${MODEL_SPEC_ACCESSIBLE_SKILL} always-apply body was missing its marker`);
+ for (const name of assertion.forbidden) {
+ if (promptHasSkillCatalogEntry(promptText, name)) {
+ failures.push(`${name} leaked into the model-visible catalog`);
+ }
+ if (skillPrimeMessages.some((message) => message.name === name)) {
+ failures.push(`${name} was unexpectedly primed`);
+ }
+ if (name === MODEL_SPEC_ACCESSIBLE_SKILL && promptText.includes(ALWAYS_APPLY_BODY_MARKER)) {
+ failures.push(`${name} always-apply body marker leaked into the model prompt`);
+ }
+ if (name === DEPLOYMENT_SKILL_NAME && promptText.includes(DEPLOYMENT_SKILL_BODY_MARKER)) {
+ failures.push(`${name} always-apply body marker leaked into the model prompt`);
+ }
}
- if (skillPrimeMessages.some((message) => message.name === MODEL_SPEC_MISSING_SKILL)) {
- failures.push(`${MODEL_SPEC_MISSING_SKILL} was unexpectedly primed`);
+ if (failures.length > 0) {
+ return {
+ responses: [`E2E skill assertion failed: ${failures.join('; ')}`],
+ };
}
- if (skillPrimeMessages.some((message) => message.name === MODEL_SPEC_INACCESSIBLE_SKILL)) {
- failures.push(`${MODEL_SPEC_INACCESSIBLE_SKILL} was unexpectedly primed`);
+ return {
+ responses: [
+ `${SKILL_ASSERTION_FINAL_TEXT}: ${
+ assertion.required.length > 0 ? assertion.required.join(', ') : 'none'
+ }`,
+ ],
+ };
+}
+
+function manualSkillAssertionResponses({ messages, skillName }) {
+ const taggedPrime = collectSkillPrimeMessages(messages).find(
+ (message) => message.name === skillName && message.trigger === 'manual',
+ );
+ if (!taggedPrime) {
+ return {
+ responses: [`E2E manual skill assertion failed: ${skillName} was not manually primed`],
+ };
+ }
+ if (!taggedPrime.content.includes(`# ${skillName}`)) {
+ return {
+ responses: [`E2E manual skill assertion failed: ${skillName} body was missing`],
+ };
}
+ return {
+ responses: [`${MANUAL_SKILL_ASSERTION_FINAL_TEXT}: ${skillName}`],
+ };
+}
- if (failures.length > 0) {
+/**
+ * Exercises the real event-driven `skill` handler. The first model call emits
+ * the tool request; the second verifies both the visible tool result and the
+ * body-bearing meta HumanMessage that ToolNode reinjected for the model.
+ */
+function skillToolInvocationResponses({ skillName, toolNames }) {
+ if (!toolNames.has(SKILL_TOOL_NAME)) {
return {
- responses: [`E2E model spec skill assertion failed: ${failures.join('; ')}`],
+ responses: [`E2E skill tool assertion failed: ${SKILL_TOOL_NAME} was not advertised`],
};
}
+
return {
- responses: [`${MODEL_SPEC_SKILL_ASSERTION_FINAL_TEXT}: ${MODEL_SPEC_ACCESSIBLE_SKILL}`],
+ responses: ['', ''],
+ toolCalls: [
+ {
+ id: `call_e2e_skill_${skillName}`,
+ name: SKILL_TOOL_NAME,
+ args: { skillName },
+ type: 'tool_call',
+ },
+ ],
+ resolveOnStream: (streamMessages) => {
+ const toolResult = findLastToolMessageText(
+ streamMessages,
+ `Skill "${skillName}" loaded. Follow the instructions below.`,
+ );
+ if (!toolResult) {
+ return null;
+ }
+
+ const expectedMarker = expectedSkillBodyMarker(skillName);
+ const modelInvokedPrime = collectSkillPrimeMessages(streamMessages).find(
+ (message) =>
+ message.name === skillName &&
+ message.trigger == null &&
+ message.content.includes(expectedMarker),
+ );
+ if (!modelInvokedPrime) {
+ return {
+ responses: [
+ `E2E skill tool assertion failed: ${skillName} body was not reinjected with marker "${expectedMarker}"`,
+ ],
+ };
+ }
+ return {
+ responses: [`${SKILL_TOOL_ASSERTION_FINAL_TEXT}: ${skillName}`],
+ };
+ },
};
}
@@ -740,7 +924,7 @@ function backgroundCollectResponses(messages, toolNames) {
};
}
-function resolveResponses({ agents, messages, text, toolNames }) {
+function resolveResponses({ graph, messages, text, toolNames }) {
const reply = replyResponses(text);
if (reply) {
return reply;
@@ -769,8 +953,50 @@ function resolveResponses({ agents, messages, text, toolNames }) {
return quoteAssertion;
}
- if (text.includes(ASSERT_MODEL_SPEC_SKILLS_MARKER)) {
- return modelSpecSkillAssertionResponses({ agents, messages, toolNames });
+ if (text.includes(ASSERT_SKILLS_MARKER)) {
+ return {
+ responses: [MOCK_REPLY],
+ resolveOnStream: async (streamMessages, streamOptions, runManager) => {
+ const agentView = await getStreamAgentView({
+ graph,
+ messages: streamMessages,
+ options: streamOptions,
+ runManager,
+ });
+ return skillAssertionResponses({
+ messages: agentView.messages,
+ assertion: parseSkillAssertion(text, agentView.agentId),
+ toolNames: agentView.toolNames,
+ });
+ },
+ };
+ }
+
+ if (text.includes(ASSERT_MANUAL_SKILL_MARKER)) {
+ const skillName = getMarkerValue(text, ASSERT_MANUAL_SKILL_MARKER);
+ return {
+ responses: [MOCK_REPLY],
+ resolveOnStream: async (streamMessages, streamOptions, runManager) => {
+ const agentView = await getStreamAgentView({
+ graph,
+ messages: streamMessages,
+ options: streamOptions,
+ runManager,
+ });
+ return manualSkillAssertionResponses({
+ messages: agentView.messages,
+ skillName,
+ });
+ },
+ };
+ }
+
+ const invokedSkillName = getMarkerValue(text, INVOKE_SKILL_MARKER);
+ if (invokedSkillName) {
+ return skillToolInvocationResponses({
+ skillName: invokedSkillName,
+ toolNames,
+ });
}
const createSkillName = getRequestedSkillName(text, CREATE_SKILL_MARKER);
@@ -824,7 +1050,7 @@ module.exports = function fakeModelHook(run, context) {
const text = getLatestUserText(context?.messages);
const toolNames = collectToolNames(context?.agents);
const { responses, sleep, toolCalls, thrownError, resolveOnStream } = resolveResponses({
- agents: context?.agents,
+ graph,
messages: context?.messages,
text,
toolNames,
diff --git a/e2e/specs/mock/agent-skills-added.spec.ts b/e2e/specs/mock/agent-skills-added.spec.ts
new file mode 100644
index 0000000000..b4e3c95a0d
--- /dev/null
+++ b/e2e/specs/mock/agent-skills-added.spec.ts
@@ -0,0 +1,174 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import { cleanupAgent, openAgentBuilder, uniqueAgentName } from './agents.helpers';
+import { NEW_CHAT_PATH, fetchJson, getAccessToken, requestJson, sendMessage } from './helpers';
+
+const DEPLOYMENT_SKILL_NAME = 'e2e-deployment-skill';
+const ASSERTION_MARKER = 'E2E_ASSERT_SKILLS:';
+const ASSERTION_FINAL_TEXT = 'E2E skill assertion passed';
+
+type SkillSummary = {
+ _id: string;
+ name: string;
+ source?: string;
+};
+
+type AgentResponse = {
+ id: string;
+ name?: string | null;
+ skills?: string[];
+ skills_enabled?: boolean;
+};
+
+type AgentChatPayload = {
+ addedConvo?: {
+ agent_id?: string;
+ endpoint?: string;
+ };
+};
+
+async function getDeploymentSkill(page: Page, token: string): Promise<SkillSummary> {
+ const result = await fetchJson<{ skills?: SkillSummary[] }>(
+ page,
+ `/api/skills?search=${encodeURIComponent(DEPLOYMENT_SKILL_NAME)}&limit=10`,
+ token,
+ );
+ const skill = result.skills?.find((item) => item.name === DEPLOYMENT_SKILL_NAME);
+ expect(skill).toMatchObject({
+ name: DEPLOYMENT_SKILL_NAME,
+ source: 'deployment',
+ });
+ return skill!;
+}
+
+async function selectAddedAgent(page: Page, agentName: string) {
+ const messageInput = page.getByRole('textbox', { name: 'Message input' });
+ await messageInput.click();
+ await messageInput.pressSequentially('+');
+
+ const addedModelSearch = page.getByPlaceholder(
+ 'Add a model or preset for an additional response',
+ );
+ await expect(addedModelSearch).toBeVisible();
+ await addedModelSearch.fill(agentName);
+
+ const agentOption = page.locator('button[id^="add-convo-item-"]').filter({ hasText: agentName });
+ await expect(agentOption).toHaveCount(1);
+ await agentOption.click();
+
+ await expect(page.getByText(`+ ${agentName}`, { exact: true })).toBeVisible();
+ await expect(messageInput).toHaveValue('');
+}
+
+async function selectPrimaryAgent(page: Page, agentName: string) {
+ const form = await openAgentBuilder(page);
+ await form.getByRole('combobox', { name: 'Agent', exact: true }).click();
+ await page.getByRole('option', { name: agentName, exact: true }).click();
+ await expect(form.getByLabel('Agent name')).toHaveValue(agentName);
+ await form.getByRole('button', { name: 'Select Agent' }).click();
+}
+
+async function settleCleanup(tasks: Promise<unknown>[]) {
+ const results = await Promise.allSettled(tasks);
+ const failures = results.filter(
+ (result): result is PromiseRejectedResult => result.status === 'rejected',
+ );
+ if (failures.length > 0) {
+ throw failures[0].reason;
+ }
+}
+
+test.describe('added agent skills', () => {
+ test('keeps an added agent deployment-skill catalog scoped to that agent', async ({ page }) => {
+ test.setTimeout(120000);
+
+ const primaryAgentName = uniqueAgentName('E2E Primary Skill Agent');
+ const addedAgentName = uniqueAgentName('E2E Added Skill Agent');
+ let primaryAgentId: string | undefined;
+ let addedAgentId: string | undefined;
+
+ try {
+ await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
+ const token = await getAccessToken(page);
+ const deploymentSkill = await getDeploymentSkill(page, token);
+
+ const primaryAgent = await requestJson<AgentResponse>(page, {
+ path: '/api/agents',
+ token,
+ method: 'POST',
+ body: {
+ name: primaryAgentName,
+ description: 'Primary agent without skills for added-agent scope coverage.',
+ instructions: 'Respond as the primary agent.',
+ provider: 'Mock Provider A',
+ model: 'mock-model-a',
+ model_parameters: {},
+ skills_enabled: false,
+ skills: [],
+ },
+ });
+ primaryAgentId = primaryAgent.id;
+
+ const addedAgent = await requestJson<AgentResponse>(page, {
+ path: '/api/agents',
+ token,
+ method: 'POST',
+ body: {
+ name: addedAgentName,
+ description: 'Persisted added-agent deployment skill regression fixture.',
+ instructions: 'Use the configured deployment skill when responding.',
+ provider: 'Mock Provider B',
+ model: 'mock-model-b',
+ model_parameters: {},
+ skills_enabled: true,
+ skills: [deploymentSkill._id],
+ },
+ });
+ addedAgentId = addedAgent.id;
+ expect(addedAgent).toMatchObject({
+ name: addedAgentName,
+ skills_enabled: true,
+ skills: [deploymentSkill._id],
+ });
+
+ await selectPrimaryAgent(page, primaryAgentName);
+ await selectAddedAgent(page, addedAgentName);
+
+ const scopedAssertion = `${ASSERTION_MARKER}${primaryAgentId}=!${DEPLOYMENT_SKILL_NAME};${addedAgentId}=${DEPLOYMENT_SKILL_NAME}`;
+ const response = await sendMessage(
+ page,
+ [scopedAssertion, 'Verify the persisted added-agent skill catalog.'].join('\n'),
+ );
+ expect(response.ok()).toBeTruthy();
+
+ const payload = response.request().postDataJSON() as AgentChatPayload;
+ expect(payload.addedConvo).toMatchObject({
+ agent_id: addedAgentId,
+ endpoint: 'agents',
+ });
+
+ const parallelGroup = page
+ .getByTestId('messages-view')
+ .locator('.sibling-content-group')
+ .last();
+ const addedAgentColumn = parallelGroup
+ .locator(':scope > div')
+ .filter({ hasText: addedAgentName });
+ await expect(addedAgentColumn).toHaveCount(1);
+ await expect(addedAgentColumn).toContainText(
+ `${ASSERTION_FINAL_TEXT}: ${DEPLOYMENT_SKILL_NAME}`,
+ { timeout: 30000 },
+ );
+
+ const primaryColumn = parallelGroup
+ .locator(':scope > div')
+ .filter({ hasText: primaryAgentName });
+ await expect(primaryColumn).toHaveCount(1);
+ await expect(primaryColumn).toContainText(`${ASSERTION_FINAL_TEXT}: none`, {
+ timeout: 30000,
+ });
+ } finally {
+ await settleCleanup([cleanupAgent(page, primaryAgentId), cleanupAgent(page, addedAgentId)]);
+ }
+ });
+});
diff --git a/e2e/specs/mock/agent-skills.spec.ts b/e2e/specs/mock/agent-skills.spec.ts
new file mode 100644
index 0000000000..1a9aad155d
--- /dev/null
+++ b/e2e/specs/mock/agent-skills.spec.ts
@@ -0,0 +1,810 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page, Request, Response } from '@playwright/test';
+import type { AgentDetail } from './agents.helpers';
+import {
+ cleanupAgent,
+ openAgentBuilder,
+ selectMockModel,
+ uniqueAgentName,
+ waitForPersistedAgent,
+} from './agents.helpers';
+import { fetchJson, getAccessToken, requestJson, sendMessage } from './helpers';
+
+const DEPLOYMENT_SKILL_NAME = 'e2e-deployment-skill';
+const SKILL_ASSERTION_MARKER = 'E2E_ASSERT_SKILLS:';
+const SKILL_ASSERTION_FINAL_TEXT = 'E2E skill assertion passed';
+const MANUAL_SKILL_ASSERTION_MARKER = 'E2E_ASSERT_MANUAL_SKILL:';
+const MANUAL_SKILL_ASSERTION_FINAL_TEXT = 'E2E manual skill assertion passed';
+const SKILL_TOOL_INVOCATION_MARKER = 'E2E_INVOKE_SKILL:';
+const SKILL_TOOL_ASSERTION_FINAL_TEXT = 'E2E skill tool assertion passed';
+const SKILL_PICKER_PLACEHOLDER = 'Select a Skill by name';
+const NO_SKILLS_FOUND_TEXT = 'No skills found';
+const INLINE_SKILL_DESCRIPTION =
+ 'Use this inline skill to verify Agent Builder skill selection and persistence.';
+
+type SkillSummary = {
+ _id: string;
+ name: string;
+ description: string;
+ source?: string;
+ sourceMetadata?: {
+ deployment?: boolean;
+ };
+};
+
+type SkillAgentDetail = AgentDetail & {
+ skills?: string[];
+ skills_enabled?: boolean;
+};
+
+type AgentSkillPayload = {
+ name?: string;
+ skills?: string[];
+ skills_enabled?: boolean;
+ manualSkills?: string[];
+};
+
+const uniqueSkillName = (prefix: string) =>
+ `${prefix}-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e4)}`;
+
+async function createInlineSkill(page: Page, token: string, name: string): Promise<SkillSummary> {
+ return requestJson<SkillSummary>(page, {
+ path: '/api/skills',
+ token,
+ method: 'POST',
+ body: {
+ name,
+ description: INLINE_SKILL_DESCRIPTION,
+ body: `# ${name}\n\nUse this skill in Agent Builder end-to-end tests.`,
+ },
+ });
+}
+
+async function createInlineSkills(
+ page: Page,
+ token: string,
+ names: string[],
+ onCreated?: (skill: SkillSummary) => void,
+): Promise<SkillSummary[]> {
+ const created: SkillSummary[] = [];
+ const batchSize = 10;
+ for (let index = 0; index < names.length; index += batchSize) {
+ const batch = await Promise.allSettled(
+ names.slice(index, index + batchSize).map((name) => createInlineSkill(page, token, name)),
+ );
+ for (const result of batch) {
+ if (result.status === 'fulfilled') {
+ created.push(result.value);
+ onCreated?.(result.value);
+ }
+ }
+ const failed = batch.find((result) => result.status === 'rejected');
+ if (failed?.status === 'rejected') {
+ throw failed.reason;
+ }
+ }
+ return created;
+}
+
+async function getDeploymentSkill(page: Page, token: string): Promise<SkillSummary> {
+ const result = await fetchJson<{ skills?: SkillSummary[] }>(
+ page,
+ `/api/skills?search=${encodeURIComponent(DEPLOYMENT_SKILL_NAME)}&limit=10`,
+ token,
+ );
+ const skill = result.skills?.find((item) => item.name === DEPLOYMENT_SKILL_NAME);
+ expect(skill, 'Expected the deployment skill fixture to be accessible').toMatchObject({
+ name: DEPLOYMENT_SKILL_NAME,
+ source: 'deployment',
+ sourceMetadata: { deployment: true },
+ });
+ return skill!;
+}
+
+async function deleteSkill(page: Page, token: string, skillId: string): Promise<void> {
+ await requestJson(page, {
+ path: `/api/skills/${encodeURIComponent(skillId)}`,
+ token,
+ method: 'DELETE',
+ });
+}
+
+async function deleteSkills(page: Page, token: string, skillIds: string[]): Promise<void> {
+ const batchSize = 10;
+ const failures: unknown[] = [];
+ for (let index = 0; index < skillIds.length; index += batchSize) {
+ const results = await Promise.allSettled(
+ skillIds.slice(index, index + batchSize).map((skillId) => deleteSkill(page, token, skillId)),
+ );
+ for (const result of results) {
+ if (result.status === 'rejected') {
+ failures.push(result.reason);
+ }
+ }
+ }
+ if (failures.length > 0) {
+ throw failures[0];
+ }
+}
+
+async function settleCleanup(tasks: Promise<unknown>[]): Promise<void> {
+ const results = await Promise.allSettled(tasks);
+ const failures = results.filter(
+ (result): result is PromiseRejectedResult => result.status === 'rejected',
+ );
+ if (failures.length > 0) {
+ throw failures[0].reason;
+ }
+}
+
+async function openSkillsDialog(page: Page, form: Locator): Promise<Locator> {
+ await form.getByRole('button', { name: 'Add Skills', exact: true }).click();
+ const dialog = page
+ .getByRole('dialog')
+ .filter({ hasText: 'Browse and add skills to your agent.' });
+ await expect(dialog).toBeVisible();
+ return dialog;
+}
+
+async function skillCard(dialog: Locator, name: string): Promise<Locator> {
+ const item = dialog
+ .getByRole('list', { name: 'Skills' })
+ .getByRole('listitem')
+ .filter({ hasText: name });
+ await expect(item).toHaveCount(1);
+ const card = item.getByRole('button').filter({ hasText: name }).first();
+ await expect(card).toBeVisible();
+ return card;
+}
+
+async function selectSkill(dialog: Locator, name: string): Promise<void> {
+ const card = await skillCard(dialog, name);
+ await card.click();
+ await expect(card).toHaveAttribute('aria-pressed', 'true');
+}
+
+async function waitForAgentMutation(
+ page: Page,
+ method: 'POST' | 'PATCH',
+ agentId?: string,
+): Promise<Response> {
+ return page.waitForResponse(
+ (response) => {
+ const { pathname } = new URL(response.url());
+ const expectedPath = agentId ? `/api/agents/${agentId}` : '/api/agents';
+ return response.request().method() === method && pathname === expectedPath;
+ },
+ { timeout: 30000 },
+ );
+}
+
+async function selectAgent(page: Page, form: Locator, agentName: string): Promise<void> {
+ await form.getByRole('combobox', { name: 'Agent', exact: true }).click();
+ await page.getByRole('option', { name: agentName, exact: true }).click();
+ await expect(form.getByLabel('Agent name')).toHaveValue(agentName);
+}
+
+async function openSkillPicker(page: Page): Promise<Locator> {
+ const messageInput = page.getByRole('textbox', { name: 'Message input' });
+ await messageInput.click();
+ await messageInput.fill('');
+ await messageInput.pressSequentially('$');
+ const searchInput = page.getByPlaceholder(SKILL_PICKER_PLACEHOLDER);
+ await expect(searchInput).toBeVisible();
+ return searchInput;
+}
+
+function skillPickerOption(page: Page, name: string): Locator {
+ return page.locator('button[id^="skill-item-"]').filter({ hasText: name });
+}
+
+async function expectSkillInPicker(page: Page, searchInput: Locator, name: string): Promise<void> {
+ await searchInput.fill(name);
+ await expect(skillPickerOption(page, name)).toHaveCount(1);
+ await expect(skillPickerOption(page, name)).toBeVisible();
+}
+
+async function expectSkillAbsentFromPicker(
+ page: Page,
+ searchInput: Locator,
+ name: string,
+): Promise<void> {
+ await searchInput.fill(name);
+ await expect(
+ searchInput.locator('..').getByText(NO_SKILLS_FOUND_TEXT, { exact: true }),
+ ).toBeVisible({ timeout: 30000 });
+ await expect(skillPickerOption(page, name)).toHaveCount(0);
+}
+
+async function closeSkillPicker(page: Page, searchInput: Locator): Promise<void> {
+ await searchInput.press('Escape');
+ await expect(searchInput).toBeHidden();
+ await page.getByRole('textbox', { name: 'Message input' }).fill('');
+}
+
+test.describe('Agent Builder skills', () => {
+ test('creates an agent with deployment and inline skills, then removes and persists one', async ({
+ page,
+ }) => {
+ test.setTimeout(180000);
+
+ const agentName = uniqueAgentName('E2E Agent Skills');
+ const agentDescription = 'Agent Builder skill selection end-to-end coverage.';
+ const inlineSkillName = uniqueSkillName('e2e-agent-inline');
+ const unselectedSkillName = uniqueSkillName('e2e-agent-unselected');
+ let createdAgentId: string | undefined;
+ const createdSkillIds: string[] = [];
+
+ await page.goto('/c/new', { timeout: 10000 });
+ const token = await getAccessToken(page);
+
+ try {
+ const deploymentSkill = await getDeploymentSkill(page, token);
+ const [inlineSkill] = await createInlineSkills(
+ page,
+ token,
+ [inlineSkillName, unselectedSkillName],
+ (skill) => createdSkillIds.push(skill._id),
+ );
+
+ let form = await openAgentBuilder(page);
+ await form.getByLabel('Agent name').fill(agentName);
+ await form.getByLabel('Agent description').fill(agentDescription);
+ await selectMockModel(page, true);
+ form = page.getByRole('form', { name: 'Agent configuration form' });
+
+ const dialog = await openSkillsDialog(page, form);
+ await selectSkill(dialog, DEPLOYMENT_SKILL_NAME);
+ await selectSkill(dialog, inlineSkillName);
+ await page.keyboard.press('Escape');
+ await expect(dialog).toBeHidden();
+
+ const createResponsePromise = waitForAgentMutation(page, 'POST');
+ await form.getByRole('button', { name: 'Create', exact: true }).click();
+ const createResponse = await createResponsePromise;
+ expect(createResponse.status(), await createResponse.text()).toBe(201);
+
+ const createdAgent = (await createResponse.json()) as SkillAgentDetail;
+ createdAgentId = createdAgent.id;
+ const createPayload = createResponse.request().postDataJSON() as AgentSkillPayload;
+ expect(createPayload.skills_enabled).toBe(true);
+ expect(createPayload.skills).toHaveLength(2);
+ expect(createPayload.skills).toEqual(
+ expect.arrayContaining([deploymentSkill._id, inlineSkill._id]),
+ );
+
+ expect(createdAgent).toMatchObject({
+ id: createdAgentId,
+ name: agentName,
+ skills_enabled: true,
+ });
+ expect(createdAgent.skills).toEqual(
+ expect.arrayContaining([deploymentSkill._id, inlineSkill._id]),
+ );
+
+ const persistedAgent = (await waitForPersistedAgent(
+ page,
+ agentName,
+ agentDescription,
+ )) as SkillAgentDetail;
+ expect(persistedAgent.skills_enabled).toBe(true);
+ expect(persistedAgent.skills).toEqual(
+ expect.arrayContaining([deploymentSkill._id, inlineSkill._id]),
+ );
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByText(DEPLOYMENT_SKILL_NAME, { exact: true })).toBeVisible();
+ await expect(form.getByText(inlineSkillName, { exact: true })).toBeVisible();
+
+ const retainedDescription = `${agentDescription} Saved with both skills still selected.`;
+ await form.getByLabel('Agent description').fill(retainedDescription);
+ const retentionResponsePromise = waitForAgentMutation(page, 'PATCH', createdAgentId);
+ await form.getByRole('button', { name: 'Save', exact: true }).click();
+ const retentionResponse = await retentionResponsePromise;
+ expect(retentionResponse.status(), await retentionResponse.text()).toBe(200);
+
+ const retainedAgent = (await retentionResponse.json()) as SkillAgentDetail;
+ const retentionPayload = retentionResponse.request().postDataJSON() as AgentSkillPayload;
+ expect(retentionPayload.skills_enabled).toBe(true);
+ expect(retentionPayload.skills).toHaveLength(2);
+ expect(retentionPayload.skills).toEqual(
+ expect.arrayContaining([deploymentSkill._id, inlineSkill._id]),
+ );
+ expect(retainedAgent.skills_enabled).toBe(true);
+ expect(retainedAgent.skills).toHaveLength(2);
+ expect(retainedAgent.skills).toEqual(
+ expect.arrayContaining([deploymentSkill._id, inlineSkill._id]),
+ );
+
+ const expandedRetainedAgent = await fetchJson<SkillAgentDetail>(
+ page,
+ `/api/agents/${encodeURIComponent(createdAgentId)}/expanded`,
+ token,
+ );
+ expect(expandedRetainedAgent.skills_enabled).toBe(true);
+ expect(expandedRetainedAgent.skills).toHaveLength(2);
+ expect(expandedRetainedAgent.skills).toEqual(
+ expect.arrayContaining([deploymentSkill._id, inlineSkill._id]),
+ );
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByText(DEPLOYMENT_SKILL_NAME, { exact: true })).toBeVisible();
+ await expect(form.getByText(inlineSkillName, { exact: true })).toBeVisible();
+
+ await form.getByRole('button', { name: 'Select Agent' }).click();
+ const pickerSearch = await openSkillPicker(page);
+ await expectSkillInPicker(page, pickerSearch, DEPLOYMENT_SKILL_NAME);
+ await expectSkillInPicker(page, pickerSearch, inlineSkillName);
+ await expectSkillAbsentFromPicker(page, pickerSearch, unselectedSkillName);
+ await closeSkillPicker(page, pickerSearch);
+
+ const runtimeResponse = await sendMessage(
+ page,
+ [
+ `${SKILL_ASSERTION_MARKER}*${DEPLOYMENT_SKILL_NAME},${inlineSkillName},!${unselectedSkillName}`,
+ 'Verify the persisted Agent Builder skill allowlist at runtime.',
+ ].join('\n'),
+ );
+ expect(runtimeResponse.ok()).toBeTruthy();
+ await expect(
+ page
+ .getByTestId('messages-view')
+ .getByText(`${SKILL_ASSERTION_FINAL_TEXT}: ${DEPLOYMENT_SKILL_NAME}, ${inlineSkillName}`),
+ ).toBeVisible({ timeout: 30000 });
+
+ const inlineToolResponse = await sendMessage(
+ page,
+ `${SKILL_TOOL_INVOCATION_MARKER}${inlineSkillName}`,
+ );
+ expect(inlineToolResponse.ok()).toBeTruthy();
+ await expect(
+ page
+ .getByTestId('messages-view')
+ .getByText(`${SKILL_TOOL_ASSERTION_FINAL_TEXT}: ${inlineSkillName}`),
+ ).toBeVisible({ timeout: 30000 });
+
+ const deploymentToolResponse = await sendMessage(
+ page,
+ `${SKILL_TOOL_INVOCATION_MARKER}${DEPLOYMENT_SKILL_NAME}`,
+ );
+ expect(deploymentToolResponse.ok()).toBeTruthy();
+ await expect(
+ page
+ .getByTestId('messages-view')
+ .getByText(`${SKILL_TOOL_ASSERTION_FINAL_TEXT}: ${DEPLOYMENT_SKILL_NAME}`),
+ ).toBeVisible({ timeout: 30000 });
+
+ const manualPickerSearch = await openSkillPicker(page);
+ await expectSkillInPicker(page, manualPickerSearch, inlineSkillName);
+ await skillPickerOption(page, inlineSkillName).click();
+ await expect(manualPickerSearch).toBeHidden();
+ await expect(
+ page
+ .getByRole('list', { name: 'Skills queued for next submission' })
+ .getByText(inlineSkillName, { exact: true }),
+ ).toBeVisible();
+
+ const manualResponse = await sendMessage(
+ page,
+ `${MANUAL_SKILL_ASSERTION_MARKER}${inlineSkillName}`,
+ );
+ expect(manualResponse.ok()).toBeTruthy();
+ expect((manualResponse.request().postDataJSON() as AgentSkillPayload).manualSkills).toEqual([
+ inlineSkillName,
+ ]);
+ await expect(
+ page
+ .getByTestId('messages-view')
+ .getByText(`${MANUAL_SKILL_ASSERTION_FINAL_TEXT}: ${inlineSkillName}`),
+ ).toBeVisible({ timeout: 30000 });
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ const deploymentRow = form.locator('li').filter({ hasText: DEPLOYMENT_SKILL_NAME });
+ await expect(deploymentRow).toHaveCount(1);
+ await deploymentRow.hover();
+ await deploymentRow.getByRole('button', { name: 'Remove from agent' }).click();
+ await expect(form.getByText(DEPLOYMENT_SKILL_NAME, { exact: true })).toBeHidden();
+
+ const updateResponsePromise = waitForAgentMutation(page, 'PATCH', createdAgentId);
+ await form.getByRole('button', { name: 'Save', exact: true }).click();
+ const updateResponse = await updateResponsePromise;
+ expect(updateResponse.status(), await updateResponse.text()).toBe(200);
+
+ const updatePayload = updateResponse.request().postDataJSON() as AgentSkillPayload;
+ expect(updatePayload).toMatchObject({
+ skills: [inlineSkill._id],
+ skills_enabled: true,
+ });
+
+ const updatedAgent = await fetchJson<SkillAgentDetail>(
+ page,
+ `/api/agents/${encodeURIComponent(createdAgentId)}/expanded`,
+ token,
+ );
+ expect(updatedAgent.skills).toEqual([inlineSkill._id]);
+ expect(updatedAgent.skills_enabled).toBe(true);
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByText(inlineSkillName, { exact: true })).toBeVisible();
+ await expect(form.getByText(DEPLOYMENT_SKILL_NAME, { exact: true })).toBeHidden();
+
+ const finalSkillRow = form.locator('li').filter({ hasText: inlineSkillName });
+ await expect(finalSkillRow).toHaveCount(1);
+ await finalSkillRow.hover();
+ await finalSkillRow.getByRole('button', { name: 'Remove from agent' }).click();
+ await expect(form.getByText(inlineSkillName, { exact: true })).toBeHidden();
+
+ const disableResponsePromise = waitForAgentMutation(page, 'PATCH', createdAgentId);
+ await form.getByRole('button', { name: 'Save', exact: true }).click();
+ const disableResponse = await disableResponsePromise;
+ expect(disableResponse.status(), await disableResponse.text()).toBe(200);
+ expect(disableResponse.request().postDataJSON()).toMatchObject({
+ skills: [],
+ skills_enabled: false,
+ });
+
+ const disabledAgent = await fetchJson<SkillAgentDetail>(
+ page,
+ `/api/agents/${encodeURIComponent(createdAgentId)}/expanded`,
+ token,
+ );
+ expect(disabledAgent.skills).toEqual([]);
+ expect(disabledAgent.skills_enabled).toBe(false);
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByText(DEPLOYMENT_SKILL_NAME, { exact: true })).toBeHidden();
+ await expect(form.getByText(inlineSkillName, { exact: true })).toBeHidden();
+ await form.getByRole('button', { name: 'Select Agent' }).click();
+
+ const disabledPickerSearch = await openSkillPicker(page);
+ await expectSkillAbsentFromPicker(page, disabledPickerSearch, DEPLOYMENT_SKILL_NAME);
+ await expectSkillAbsentFromPicker(page, disabledPickerSearch, inlineSkillName);
+ await closeSkillPicker(page, disabledPickerSearch);
+
+ const disabledRuntimeResponse = await sendMessage(
+ page,
+ `${SKILL_ASSERTION_MARKER}!${DEPLOYMENT_SKILL_NAME},!${inlineSkillName}`,
+ );
+ expect(disabledRuntimeResponse.ok()).toBeTruthy();
+ await expect(
+ page.getByTestId('messages-view').getByText(`${SKILL_ASSERTION_FINAL_TEXT}: none`),
+ ).toBeVisible({ timeout: 30000 });
+ } finally {
+ await settleCleanup([
+ cleanupAgent(page, createdAgentId),
+ deleteSkills(page, token, createdSkillIds),
+ ]);
+ }
+ });
+
+ test('persists explicit use-all semantics and includes skills created later', async ({
+ page,
+ }) => {
+ test.setTimeout(180000);
+
+ const agentName = uniqueAgentName('E2E Agent All Skills');
+ const agentDescription = 'Agent Builder explicit use-all-skills end-to-end coverage.';
+ const futureSkillName = uniqueSkillName('e2e-agent-future');
+ let createdAgentId: string | undefined;
+ let futureSkill: SkillSummary | undefined;
+
+ await page.goto('/c/new', { timeout: 10000 });
+ const token = await getAccessToken(page);
+
+ try {
+ let form = await openAgentBuilder(page);
+ await form.getByLabel('Agent name').fill(agentName);
+ await form.getByLabel('Agent description').fill(agentDescription);
+ await selectMockModel(page, true);
+ form = page.getByRole('form', { name: 'Agent configuration form' });
+
+ const useAllSwitch = form.getByRole('switch', { name: 'Use all skills' });
+ await expect(useAllSwitch).toHaveAttribute('aria-checked', 'false');
+ await useAllSwitch.click();
+ await expect(useAllSwitch).toHaveAttribute('aria-checked', 'true');
+ await expect(form.getByRole('button', { name: 'Add Skills', exact: true })).toHaveCount(0);
+
+ const createResponsePromise = waitForAgentMutation(page, 'POST');
+ await form.getByRole('button', { name: 'Create', exact: true }).click();
+ const createResponse = await createResponsePromise;
+ expect(createResponse.status(), await createResponse.text()).toBe(201);
+
+ const createdAgent = (await createResponse.json()) as SkillAgentDetail;
+ createdAgentId = createdAgent.id;
+ const createPayload = createResponse.request().postDataJSON() as AgentSkillPayload;
+ expect(createPayload).toMatchObject({
+ skills: [],
+ skills_enabled: true,
+ });
+
+ expect(createdAgent).toMatchObject({
+ id: createdAgentId,
+ skills: [],
+ skills_enabled: true,
+ });
+
+ const persistedAgent = (await waitForPersistedAgent(
+ page,
+ agentName,
+ agentDescription,
+ )) as SkillAgentDetail;
+ expect(persistedAgent.skills).toEqual([]);
+ expect(persistedAgent.skills_enabled).toBe(true);
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByRole('switch', { name: 'Use all skills' })).toHaveAttribute(
+ 'aria-checked',
+ 'true',
+ );
+ await expect(form.getByRole('button', { name: 'Add Skills', exact: true })).toHaveCount(0);
+
+ futureSkill = await createInlineSkill(page, token, futureSkillName);
+ await form.getByRole('button', { name: 'Select Agent' }).click();
+ const useAllPickerSearch = await openSkillPicker(page);
+ await expectSkillInPicker(page, useAllPickerSearch, futureSkillName);
+ await closeSkillPicker(page, useAllPickerSearch);
+
+ const runtimeResponse = await sendMessage(
+ page,
+ [
+ `${SKILL_ASSERTION_MARKER}${DEPLOYMENT_SKILL_NAME},${futureSkillName}`,
+ 'Verify use-all includes a skill created after the agent was saved.',
+ ].join('\n'),
+ );
+ expect(runtimeResponse.ok()).toBeTruthy();
+ await expect(
+ page
+ .getByTestId('messages-view')
+ .getByText(`${SKILL_ASSERTION_FINAL_TEXT}: ${DEPLOYMENT_SKILL_NAME}, ${futureSkillName}`),
+ ).toBeVisible({ timeout: 30000 });
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ const persistedUseAllSwitch = form.getByRole('switch', { name: 'Use all skills' });
+ await persistedUseAllSwitch.click();
+ await expect(persistedUseAllSwitch).toHaveAttribute('aria-checked', 'false');
+ await expect(form.getByRole('button', { name: 'Add Skills', exact: true })).toBeVisible();
+
+ const updateResponsePromise = waitForAgentMutation(page, 'PATCH', createdAgentId);
+ await form.getByRole('button', { name: 'Save', exact: true }).click();
+ const updateResponse = await updateResponsePromise;
+ expect(updateResponse.status(), await updateResponse.text()).toBe(200);
+ expect(updateResponse.request().postDataJSON()).toMatchObject({
+ skills: [],
+ skills_enabled: false,
+ });
+
+ const disabledAgent = await fetchJson<SkillAgentDetail>(
+ page,
+ `/api/agents/${encodeURIComponent(createdAgentId)}/expanded`,
+ token,
+ );
+ expect(disabledAgent.skills).toEqual([]);
+ expect(disabledAgent.skills_enabled).toBe(false);
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByRole('switch', { name: 'Use all skills' })).toHaveAttribute(
+ 'aria-checked',
+ 'false',
+ );
+ await expect(form.getByRole('button', { name: 'Add Skills', exact: true })).toBeVisible();
+
+ await form.getByRole('button', { name: 'Select Agent' }).click();
+ const disabledPickerSearch = await openSkillPicker(page);
+ await expectSkillAbsentFromPicker(page, disabledPickerSearch, futureSkillName);
+ await closeSkillPicker(page, disabledPickerSearch);
+
+ const disabledRuntimeResponse = await sendMessage(
+ page,
+ [
+ `${SKILL_ASSERTION_MARKER}!${DEPLOYMENT_SKILL_NAME},!${futureSkillName}`,
+ 'Verify the master skill toggle hides every skill at runtime.',
+ ].join('\n'),
+ );
+ expect(disabledRuntimeResponse.ok()).toBeTruthy();
+ await expect(
+ page.getByTestId('messages-view').getByText(`${SKILL_ASSERTION_FINAL_TEXT}: none`),
+ ).toBeVisible({ timeout: 30000 });
+ } finally {
+ await settleCleanup([
+ cleanupAgent(page, createdAgentId),
+ ...(futureSkill ? [deleteSkill(page, token, futureSkill._id)] : []),
+ ]);
+ }
+ });
+
+ test('creates a skill inside the builder and auto-selects it for the new agent', async ({
+ page,
+ }) => {
+ test.setTimeout(180000);
+
+ const agentName = uniqueAgentName('E2E Agent Created Skill');
+ const agentDescription = 'Agent Builder inline skill creation end-to-end coverage.';
+ const skillName = uniqueSkillName('e2e-builder-created');
+ let createdAgentId: string | undefined;
+ let createdSkill: SkillSummary | undefined;
+ let agentPostCount = 0;
+ const countAgentPosts = (request: Request) => {
+ if (request.method() === 'POST' && new URL(request.url()).pathname === '/api/agents') {
+ agentPostCount += 1;
+ }
+ };
+ page.on('request', countAgentPosts);
+
+ await page.goto('/c/new', { timeout: 10000 });
+ const token = await getAccessToken(page);
+
+ try {
+ let form = await openAgentBuilder(page);
+ await form.getByLabel('Agent name').fill(agentName);
+ await form.getByLabel('Agent description').fill(agentDescription);
+ await selectMockModel(page, true);
+ form = page.getByRole('form', { name: 'Agent configuration form' });
+
+ const skillsDialog = await openSkillsDialog(page, form);
+ await skillsDialog.getByRole('button', { name: 'Create Skill', exact: true }).click();
+
+ const createSkillDialog = page
+ .getByRole('dialog')
+ .filter({ hasText: 'Write skill instructions' });
+ await expect(createSkillDialog).toBeVisible();
+ await createSkillDialog.getByLabel('Name').fill(skillName);
+ await createSkillDialog.getByLabel('Description').fill(INLINE_SKILL_DESCRIPTION);
+ await createSkillDialog
+ .getByLabel('Instructions')
+ .fill(`# ${skillName}\n\nCreated inline from Agent Builder.`);
+
+ const skillResponsePromise = page.waitForResponse(
+ (response) =>
+ response.request().method() === 'POST' &&
+ new URL(response.url()).pathname === '/api/skills',
+ { timeout: 30000 },
+ );
+ await createSkillDialog.getByRole('button', { name: 'Create', exact: true }).click();
+ const skillResponse = await skillResponsePromise;
+ expect(skillResponse.status(), await skillResponse.text()).toBe(201);
+ createdSkill = (await skillResponse.json()) as SkillSummary;
+ expect(skillResponse.request().postDataJSON()).toMatchObject({
+ name: skillName,
+ description: INLINE_SKILL_DESCRIPTION,
+ });
+ expect(agentPostCount).toBe(0);
+
+ await expect(createSkillDialog).toBeHidden();
+ const createdCard = await skillCard(skillsDialog, skillName);
+ await expect(createdCard).toHaveAttribute('aria-pressed', 'true');
+ await page.keyboard.press('Escape');
+ await expect(skillsDialog).toBeHidden();
+ await expect(form.getByText(skillName, { exact: true })).toBeVisible();
+
+ const createAgentResponsePromise = waitForAgentMutation(page, 'POST');
+ await form.getByRole('button', { name: 'Create', exact: true }).click();
+ const createAgentResponse = await createAgentResponsePromise;
+ expect(createAgentResponse.status(), await createAgentResponse.text()).toBe(201);
+ expect(agentPostCount).toBe(1);
+ const createdAgent = (await createAgentResponse.json()) as SkillAgentDetail;
+ createdAgentId = createdAgent.id;
+ expect(createAgentResponse.request().postDataJSON()).toMatchObject({
+ skills: [createdSkill._id],
+ skills_enabled: true,
+ });
+
+ expect(createdAgent).toMatchObject({
+ id: createdAgentId,
+ skills: [createdSkill._id],
+ skills_enabled: true,
+ });
+
+ const persistedAgent = (await waitForPersistedAgent(
+ page,
+ agentName,
+ agentDescription,
+ )) as SkillAgentDetail;
+ expect(persistedAgent.skills).toEqual([createdSkill._id]);
+ expect(persistedAgent.skills_enabled).toBe(true);
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByText(skillName, { exact: true })).toBeVisible();
+ } finally {
+ page.off('request', countAgentPosts);
+ await settleCleanup([
+ cleanupAgent(page, createdAgentId),
+ ...(createdSkill ? [deleteSkill(page, token, createdSkill._id)] : []),
+ ]);
+ }
+ });
+
+ test('discovers and selects a skill beyond the first 100 accessible skills', async ({ page }) => {
+ test.setTimeout(240000);
+
+ const agentName = uniqueAgentName('E2E Agent Paginated Skill');
+ const agentDescription = 'Agent Builder paginated skill discovery end-to-end coverage.';
+ const targetSkillName = uniqueSkillName('e2e-agent-off-page');
+ const fillerPrefix = uniqueSkillName('e2e-agent-page');
+ let createdAgentId: string | undefined;
+ const createdSkillIds: string[] = [];
+
+ await page.goto('/c/new', { timeout: 10000 });
+ const token = await getAccessToken(page);
+
+ try {
+ const targetSkill = await createInlineSkill(page, token, targetSkillName);
+ createdSkillIds.push(targetSkill._id);
+ const fillerNames = Array.from(
+ { length: 100 },
+ (_, index) => `${fillerPrefix}-${String(index).padStart(3, '0')}`,
+ );
+ await createInlineSkills(page, token, fillerNames, (skill) =>
+ createdSkillIds.push(skill._id),
+ );
+
+ const firstPage = await fetchJson<{
+ skills: SkillSummary[];
+ has_more: boolean;
+ after: string | null;
+ }>(page, '/api/skills?limit=100', token);
+ expect(firstPage.has_more).toBe(true);
+ expect(firstPage.after).toBeTruthy();
+ expect(firstPage.skills.some((skill) => skill._id === targetSkill._id)).toBe(false);
+
+ let form = await openAgentBuilder(page);
+ await form.getByLabel('Agent name').fill(agentName);
+ await form.getByLabel('Agent description').fill(agentDescription);
+ await selectMockModel(page, true);
+ form = page.getByRole('form', { name: 'Agent configuration form' });
+
+ const nextPageResponsePromise = page.waitForResponse(
+ (response) => {
+ const url = new URL(response.url());
+ return url.pathname === '/api/skills' && url.searchParams.has('cursor');
+ },
+ { timeout: 30000 },
+ );
+ const dialog = await openSkillsDialog(page, form);
+ const nextPageResponse = await nextPageResponsePromise;
+ expect(nextPageResponse.ok(), await nextPageResponse.text()).toBe(true);
+
+ await dialog.getByRole('textbox', { name: 'Search skills...' }).fill(targetSkillName);
+ await selectSkill(dialog, targetSkillName);
+ await page.keyboard.press('Escape');
+ await expect(dialog).toBeHidden();
+ await expect(form.getByText(targetSkillName, { exact: true })).toBeVisible();
+
+ const createResponsePromise = waitForAgentMutation(page, 'POST');
+ await form.getByRole('button', { name: 'Create', exact: true }).click();
+ const createResponse = await createResponsePromise;
+ expect(createResponse.status(), await createResponse.text()).toBe(201);
+ const createdAgent = (await createResponse.json()) as SkillAgentDetail;
+ createdAgentId = createdAgent.id;
+ expect(createResponse.request().postDataJSON()).toMatchObject({
+ skills: [targetSkill._id],
+ skills_enabled: true,
+ });
+
+ const persistedAgent = (await waitForPersistedAgent(
+ page,
+ agentName,
+ agentDescription,
+ )) as SkillAgentDetail;
+ expect(persistedAgent.skills).toEqual([targetSkill._id]);
+ expect(persistedAgent.skills_enabled).toBe(true);
+
+ form = await openAgentBuilder(page);
+ await selectAgent(page, form, agentName);
+ await expect(form.getByText(targetSkillName, { exact: true })).toBeVisible();
+ } finally {
+ await settleCleanup([
+ cleanupAgent(page, createdAgentId),
+ deleteSkills(page, token, createdSkillIds),
+ ]);
+ }
+ });
+});
diff --git a/e2e/specs/mock/model-spec-skills.spec.ts b/e2e/specs/mock/model-spec-skills.spec.ts
index b0c9394959..e1fc905acb 100644
--- a/e2e/specs/mock/model-spec-skills.spec.ts
+++ b/e2e/specs/mock/model-spec-skills.spec.ts
@@ -12,9 +12,11 @@ import {
} from './helpers';
const MODEL_SPEC_LABEL = 'E2E Skill Scope';
-const ASSERTION_MARKER = 'E2E_ASSERT_MODEL_SPEC_SKILLS';
-const ASSERTION_FINAL_TEXT = 'E2E model spec skill assertion passed';
+const ASSERTION_MARKER = 'E2E_ASSERT_SKILLS:';
+const ASSERTION_FINAL_TEXT = 'E2E skill assertion passed';
const ACCESSIBLE_SKILL_NAME = 'e2e-model-spec-allowed';
+const DEPLOYMENT_SKILL_NAME = 'e2e-deployment-skill';
+const MISSING_SKILL_NAME = 'e2e-model-spec-missing';
const INACCESSIBLE_SKILL_NAME = 'e2e-model-spec-inaccessible';
const ALWAYS_APPLY_BODY_MARKER = 'E2E_ALWAYS_APPLY_BODY_MARKER';
const INACCESSIBLE_AUTHOR_ID = new ObjectId('64f000000000000000000001');
@@ -93,7 +95,15 @@ async function seedAccessibleSkill(page: Page, token: string): Promise<SkillDeta
});
}
-async function seedInaccessibleSkill() {
+async function deleteAccessibleSkill(page: Page, token: string, skillId: string) {
+ await requestJson<{ deleted: boolean }>(page, {
+ path: `/api/skills/${encodeURIComponent(skillId)}`,
+ token,
+ method: 'DELETE',
+ });
+}
+
+async function seedInaccessibleSkill(): Promise<string> {
applyRuntimeEnv();
if (!process.env.MONGO_URI) {
throw new Error('MONGO_URI must be available for model-spec skill mock e2e tests');
@@ -141,7 +151,30 @@ async function seedInaccessibleSkill() {
});
if (skill?._id) {
await aclEntries.deleteMany({ resourceType: 'skill', resourceId: skill._id });
+ return skill._id.toString();
}
+ throw new Error(`Failed to seed inaccessible skill "${INACCESSIBLE_SKILL_NAME}"`);
+ } finally {
+ await client.close();
+ }
+}
+
+async function deleteInaccessibleSkill(skillId: string) {
+ applyRuntimeEnv();
+ if (!process.env.MONGO_URI) {
+ throw new Error('MONGO_URI must be available for model-spec skill mock e2e tests');
+ }
+
+ const client = new MongoClient(process.env.MONGO_URI);
+ await client.connect();
+ try {
+ const db = client.db();
+ const objectId = new ObjectId(skillId);
+ await db.collection('aclentries').deleteMany({
+ resourceType: 'skill',
+ resourceId: objectId,
+ });
+ await db.collection('skills').deleteOne({ _id: objectId });
} finally {
await client.close();
}
@@ -155,21 +188,60 @@ test.describe('model spec skills', () => {
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
const token = await getAccessToken(page);
- const skill = await seedAccessibleSkill(page, token);
- expect(skill.alwaysApply).toBe(true);
- await seedInaccessibleSkill();
-
- await selectModelSpec(page, MODEL_SPEC_LABEL);
- const response = await sendMessage(
- page,
- `${ASSERTION_MARKER}\nVerify model-spec skill scope and always-apply frontmatter.`,
- );
- expect(response.ok()).toBeTruthy();
+ let accessibleSkillId: string | undefined;
+ let inaccessibleSkillId: string | undefined;
+ let testFailure: unknown;
+
+ try {
+ const skill = await seedAccessibleSkill(page, token);
+ accessibleSkillId = skill._id;
+ expect(skill.alwaysApply).toBe(true);
+ inaccessibleSkillId = await seedInaccessibleSkill();
+
+ await selectModelSpec(page, MODEL_SPEC_LABEL);
+ const response = await sendMessage(
+ page,
+ [
+ `${ASSERTION_MARKER}*${ACCESSIBLE_SKILL_NAME},*${DEPLOYMENT_SKILL_NAME},!${MISSING_SKILL_NAME},!${INACCESSIBLE_SKILL_NAME}`,
+ 'Verify model-spec skill scope and always-apply frontmatter.',
+ ].join('\n'),
+ );
+ expect(response.ok()).toBeTruthy();
+
+ await expect(
+ page
+ .getByTestId('messages-view')
+ .getByText(`${ASSERTION_FINAL_TEXT}: ${ACCESSIBLE_SKILL_NAME}, ${DEPLOYMENT_SKILL_NAME}`),
+ ).toBeVisible({ timeout: 30000 });
+ } catch (error) {
+ testFailure = error;
+ } finally {
+ const cleanupTasks: Promise<unknown>[] = [];
+ if (accessibleSkillId) {
+ cleanupTasks.push(deleteAccessibleSkill(page, token, accessibleSkillId));
+ }
+ if (inaccessibleSkillId) {
+ cleanupTasks.push(deleteInaccessibleSkill(inaccessibleSkillId));
+ }
+ const cleanupResults = await Promise.allSettled(cleanupTasks);
+ const cleanupFailures = cleanupResults
+ .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+ .map((result) => result.reason);
+ if (testFailure && cleanupFailures.length > 0) {
+ testFailure = new AggregateError(
+ [testFailure, ...cleanupFailures],
+ 'The model-spec skill assertion and fixture cleanup both failed',
+ );
+ } else if (cleanupFailures.length > 0) {
+ testFailure = new AggregateError(
+ cleanupFailures,
+ 'Model-spec skill fixture cleanup failed',
+ );
+ }
+ }
- await expect(
- page
- .getByTestId('messages-view')
- .getByText(`${ASSERTION_FINAL_TEXT}: ${ACCESSIBLE_SKILL_NAME}`),
- ).toBeVisible({ timeout: 30000 });
+ if (testFailure) {
+ throw testFailure;
+ }
});
});