| import { afterEach, describe, expect, it } from 'vitest'; |
|
|
| import { InMemorySkillCatalog } from '#/features/skill/catalog/registry'; |
|
|
| import { stubSkill } from './catalog/stubs'; |
| import { createTestAgent, skillServices, type TestAgentContext } from '../../harness'; |
|
|
| describe('activateSkill', () => { |
| let ctx: TestAgentContext; |
|
|
| afterEach(async () => { |
| try { |
| await ctx.expectResumeMatches(); |
| } finally { |
| await ctx.dispose(); |
| } |
| }); |
|
|
| function agentWithCommitSkill(): TestAgentContext { |
| const catalog = new InMemorySkillCatalog(); |
| catalog.register(stubSkill('commit', { content: '# Commit body' })); |
| return createTestAgent(skillServices(catalog)); |
| } |
|
|
| it('launches a turn with the rendered skill prompt and returns its id', async () => { |
| ctx = agentWithCommitSkill(); |
| ctx.mockNextResponse({ type: 'text', text: 'committed' }); |
|
|
| const launched = await ctx.rpc.activateSkill({ name: 'commit', args: '-m fix' }); |
| expect(launched?.turn_id).toBe(0); |
|
|
| await ctx.untilTurnEnd(); |
| const llmInput = JSON.stringify(ctx.llmInputs()); |
| expect(llmInput).toContain('skill-loaded'); |
| expect(llmInput).toContain('# Commit body'); |
| expect(llmInput).toContain('ARGUMENTS: -m fix'); |
| }); |
|
|
| it('rejects for an unknown skill instead of failing silently', async () => { |
| ctx = agentWithCommitSkill(); |
|
|
| await expect(ctx.rpc.activateSkill({ name: 'missing' })).rejects.toThrow(/not found/i); |
| }); |
| }); |
|
|
| describe('promptWithSkills', () => { |
| let ctx: TestAgentContext; |
|
|
| afterEach(async () => { |
| try { |
| await ctx.expectResumeMatches(); |
| } finally { |
| await ctx.dispose(); |
| } |
| }); |
|
|
| function agentWithSkills(): TestAgentContext { |
| const catalog = new InMemorySkillCatalog(); |
| catalog.register(stubSkill('review', { content: '# Review body' })); |
| catalog.register(stubSkill('security', { content: '# Security body' })); |
| return createTestAgent(skillServices(catalog)); |
| } |
|
|
| it('bundles every skill into the prompt message and launches exactly one turn', async () => { |
| ctx = agentWithSkills(); |
| ctx.mockNextResponse({ type: 'text', text: 'done' }); |
|
|
| const launched = await ctx.rpc.promptWithSkills({ |
| input: [{ type: 'text', text: 'Review this change.' }], |
| skills: [{ name: 'review' }, { name: 'security' }], |
| }); |
| expect(launched.turn_id).toBe(0); |
| expect(launched.prompt_id).toBeTruthy(); |
| expect(launched.state).toBe('running'); |
| await ctx.untilTurnEnd(); |
|
|
| expect(ctx.llmCalls).toHaveLength(1); |
| const llmInput = JSON.stringify(ctx.llmInputs()); |
| expect(llmInput).toContain('# Review body'); |
| expect(llmInput).toContain('# Security body'); |
| expect(llmInput).toContain('Review this change.'); |
|
|
| const messages = ctx.context.get(); |
| const promptMessage = messages.find((message) => message.origin?.kind === 'user'); |
| expect(messages.filter((message) => message.origin?.kind === 'skill_activation')).toHaveLength( |
| 0, |
| ); |
| expect(promptMessage?.origin).toMatchObject({ |
| kind: 'user', |
| skillActivations: [{ skillName: 'review' }, { skillName: 'security' }], |
| }); |
| const texts = promptMessage?.content |
| .filter((part) => part.type === 'text') |
| .map((part) => part.text); |
| expect(texts?.[0]).toContain('# Review body'); |
| expect(texts?.[1]).toContain('# Security body'); |
| expect(texts?.[2]).toContain('Review this change.'); |
|
|
| const events = ctx.allEvents.filter( |
| (event) => |
| event.type === '[rpc]' && |
| (event.event === 'skill.activated' || event.event === 'turn.started'), |
| ); |
| expect(events.map((event) => event.event)).toEqual([ |
| 'skill.activated', |
| 'skill.activated', |
| 'turn.started', |
| ]); |
| expect( |
| events |
| .slice(0, 2) |
| .map((event) => (event.args as { readonly skillName?: string }).skillName), |
| ).toEqual(['review', 'security']); |
| const started = events[2]?.args as { readonly prompt?: string }; |
| expect(started.prompt).toBe('Review this change.'); |
| }); |
|
|
| it('rejects the whole submission when any skill is unknown', async () => { |
| ctx = agentWithSkills(); |
|
|
| await expect( |
| ctx.rpc.promptWithSkills({ |
| input: [{ type: 'text', text: 'Review this change.' }], |
| skills: [{ name: 'review' }, { name: 'missing' }], |
| }), |
| ).rejects.toThrow(/not found/i); |
|
|
| expect(ctx.llmCalls).toHaveLength(0); |
| expect(ctx.context.get()).toHaveLength(0); |
| expect( |
| ctx.allEvents.some((event) => event.type === '[rpc]' && event.event === 'skill.activated'), |
| ).toBe(false); |
| }); |
|
|
| it('rejects a grouped submission with an empty prompt message', async () => { |
| ctx = agentWithSkills(); |
|
|
| await expect( |
| ctx.rpc.promptWithSkills({ |
| input: [], |
| skills: [{ name: 'review' }], |
| }), |
| ).rejects.toThrow(/non-empty prompt/i); |
|
|
| expect(ctx.llmCalls).toHaveLength(0); |
| expect(ctx.context.get()).toHaveLength(0); |
| expect( |
| ctx.allEvents.some((event) => event.type === '[rpc]' && event.event === 'skill.activated'), |
| ).toBe(false); |
| }); |
|
|
| it('rejects a grouped submission without any skills', async () => { |
| ctx = agentWithSkills(); |
|
|
| await expect( |
| ctx.rpc.promptWithSkills({ |
| input: [{ type: 'text', text: 'Review this change.' }], |
| skills: [], |
| }), |
| ).rejects.toThrow(/at least one skill/i); |
|
|
| expect(ctx.llmCalls).toHaveLength(0); |
| expect(ctx.context.get()).toHaveLength(0); |
| expect( |
| ctx.allEvents.some((event) => event.type === '[rpc]' && event.event === 'skill.activated'), |
| ).toBe(false); |
| }); |
|
|
| it('undoes the bundled prompt as a single anchor', async () => { |
| ctx = agentWithSkills(); |
| await ctx.restorePersisted(); |
| ctx.mockNextResponse({ type: 'text', text: 'done' }); |
| await ctx.rpc.promptWithSkills({ |
| input: [{ type: 'text', text: 'Review this change.' }], |
| skills: [{ name: 'review' }, { name: 'security' }], |
| }); |
| await ctx.untilTurnEnd(); |
| expect(ctx.context.get().length).toBeGreaterThan(0); |
|
|
| const undone = await ctx.rpc.undoHistory({ count: 1 }); |
| expect(undone).toBe(1); |
| expect(ctx.context.get()).toHaveLength(0); |
| }); |
|
|
| it('accepts later prompt_id reuse of a bundled prompt id as a pure correlation id', async () => { |
| ctx = agentWithSkills(); |
| ctx.mockNextResponse({ type: 'text', text: 'done' }); |
| const launched = await ctx.rpc.promptWithSkills({ |
| input: [{ type: 'text', text: 'Review this change.' }], |
| skills: [{ name: 'review' }], |
| }); |
| await ctx.untilTurnEnd(); |
|
|
| ctx.mockNextResponse({ type: 'text', text: 'again done' }); |
| const reused = await ctx.rpc.prompt({ |
| input: [{ type: 'text', text: 'again' }], |
| promptId: launched.prompt_id, |
| }); |
| expect(reused).toEqual({ turn_id: 1 }); |
| await ctx.untilTurnEnd(); |
| }); |
| }); |
|
|
