| import { beforeEach, describe, expect, it } from 'vitest'; |
| import { z } from 'zod'; |
|
|
| import { |
| type CollectionToken, |
| type CollectionView, |
| } from '#/_base/di/collection'; |
| import { ScopeUnits } from '#/_base/di/fiber'; |
| import { createDecorator, ScopeActivation } from '#/_base/di/instantiation'; |
| import { type InstantiationService } from '#/_base/di/instantiationService'; |
| import { |
| _clearScopedRegistryForTests, |
| getScopedServiceDescriptors, |
| registerScopedService, |
| type Scope, |
| } from '#/_base/di/scope'; |
| import { Service } from '#/_base/di/service'; |
| import { createScopedTestHost } from '#/_base/di/test'; |
| import { AgentProfileContribution } from '#/app/agentProfileCatalog/agentProfileContribution'; |
| import { ConfigSectionContribution } from '#/app/config/configSectionContributions'; |
| import { IFeatureManager } from '#/app/feature/featureManager'; |
| import { FeatureManagerService } from '#/app/feature/featureManagerService'; |
| import { LifecycleScope } from '#/app/scopes'; |
| import { AgentToolContribution } from '#/agent/toolRegistry/toolContribution'; |
| import { Feature } from '#/features/feature'; |
| import { IFeatureAssemblyService } from '#/features/featureAssembly'; |
| import { FeatureAssemblyService } from '#/features/featureAssemblyService'; |
| import { |
| AgentModel, |
| AgentModelContribution, |
| defineAgentModel, |
| SessionModelContribution, |
| type SessionModelDefinition, |
| } from '#/state/agentModel'; |
| import { |
| _clearFeatureRecipesForTests, |
| registerFeature, |
| } from '#/features/featureRegistry'; |
| import type { AgentTool, ToolExecution } from '#/tool/toolContract'; |
|
|
| interface IGreeter { |
| readonly _serviceBrand: undefined; |
| greet(): string; |
| } |
| const IGreeter = createDecorator<IGreeter>('test-feature-greeter'); |
|
|
| class GreeterService extends Service implements IGreeter { |
| declare readonly _serviceBrand: undefined; |
| greet(): string { |
| return 'hi'; |
| } |
| } |
|
|
| interface ITestTool extends AgentTool {} |
| const ITestTool = createDecorator<ITestTool>('test-feature-tool'); |
|
|
| class TestTool implements ITestTool { |
| declare readonly _serviceBrand: undefined; |
| readonly name = 'TestTool'; |
| readonly description = 'test tool'; |
| readonly parameters = {}; |
|
|
| resolveExecution(): ToolExecution { |
| return { |
| approvalRule: this.name, |
| execute: async () => ({ output: '' }), |
| }; |
| } |
| } |
|
|
| const TestConfigSchema = { |
| '~standard': { |
| validate: (value: unknown) => ({ value }), |
| }, |
| } as never; |
|
|
| function collectionViewOf<T>(scope: Scope, token: CollectionToken<T>): CollectionView<T> { |
| return (scope.instantiation as InstantiationService).fiberHost.collectionView(token); |
| } |
|
|
| describe('Feature — built-in capability assembly (src/features)', () => { |
| beforeEach(() => { |
| _clearScopedRegistryForTests(); |
| _clearFeatureRecipesForTests(); |
| registerScopedService( |
| LifecycleScope.App, |
| IFeatureManager, |
| FeatureManagerService, |
| ScopeActivation.OnScopeCreated, |
| 'feature', |
| ); |
| registerScopedService( |
| LifecycleScope.App, |
| IFeatureAssemblyService, |
| FeatureAssemblyService, |
| ScopeActivation.OnScopeCreated, |
| 'features', |
| ); |
| }); |
|
|
| it('assembles a registered feature and materializes its contributions per Agent scope', async () => { |
| const disposed: string[] = []; |
|
|
| class TestFeature extends Feature { |
| static override readonly name = 'test-feature'; |
|
|
| constructor() { |
| super(); |
| this.contributeConfig('testFeatureSection', TestConfigSchema, { defaultValue: false }); |
| this.contributeAgentService(IGreeter, GreeterService); |
| this.contributeTool(ITestTool, TestTool, { name: 'TestTool' }); |
| this.contributeProfiles([{ name: 'test-profile' } as never]); |
| this.onDispose(() => disposed.push('test-feature')); |
| } |
| } |
| registerFeature(TestFeature); |
|
|
| const host = createScopedTestHost(); |
| const manager = host.app.accessor.get(IFeatureManager); |
| expect(manager.units()).toHaveLength(1); |
| expect(manager.units()[0]!.name).toBe('test-feature'); |
|
|
| const configView = collectionViewOf(host.app, ConfigSectionContribution); |
| expect(configView.items.map((item) => item.domain)).toContain('testFeatureSection'); |
|
|
| const profileView = collectionViewOf(host.app, AgentProfileContribution); |
| expect(profileView.items).toHaveLength(1); |
| expect(profileView.items[0]!.sourceId).toBe('feature:test-feature'); |
|
|
| const agentOne = host.child(LifecycleScope.Agent, 'agent-1'); |
| const agentTwo = host.child(LifecycleScope.Agent, 'agent-2'); |
| expect(agentOne.accessor.get(IGreeter).greet()).toBe('hi'); |
| expect(agentTwo.accessor.get(IGreeter).greet()).toBe('hi'); |
| expect(agentOne.accessor.get(IGreeter)).not.toBe(agentTwo.accessor.get(IGreeter)); |
|
|
| const toolView = collectionViewOf(agentOne, AgentToolContribution); |
| expect(toolView.items).toHaveLength(1); |
| expect(toolView.items[0]!.options.name).toBe('TestTool'); |
| expect(agentOne.accessor.get(ITestTool).name).toBe('TestTool'); |
|
|
| await manager.unprovideUnit('test-feature'); |
| await host.app.instantiation.cascade.whenIdle(); |
| await new Promise((resolve) => setTimeout(resolve, 0)); |
|
|
| expect(manager.units()).toHaveLength(0); |
| expect(disposed).toEqual(['test-feature']); |
| expect(configView.items.map((item) => item.domain)).not.toContain('testFeatureSection'); |
| expect(profileView.items).toHaveLength(0); |
| expect(toolView.items).toHaveLength(0); |
| expect(() => agentOne.accessor.get(IGreeter)).toThrow(); |
| expect(() => agentOne.accessor.get(ITestTool)).toThrow(); |
|
|
| host.dispose(); |
| }); |
|
|
| it('registers model definitions and retracts them on unload', async () => { |
| const sessionModel: SessionModelDefinition<number> = { |
| id: 'test-feature.session-model', |
| state: { initial: () => 0, schema: z.custom<number>() }, |
| events: [], |
| undoable: false, |
| }; |
| const agentModel = defineAgentModel({ |
| id: 'test-feature.agent-model', |
| model: class extends AgentModel<number> {}, |
| state: { initial: () => 0, schema: z.custom<number>() }, |
| events: [], |
| }); |
| class DomainFeature extends Feature { |
| static override readonly name = 'domain-definitions'; |
|
|
| constructor() { |
| super(); |
| this.contributeSessionModel(sessionModel); |
| this.contributeAgentModel(agentModel); |
| } |
| } |
| class ReplacementFeature extends Feature { |
| static override readonly name = 'replacement-definitions'; |
|
|
| constructor() { |
| super(); |
| this.contributeAgentModel(agentModel); |
| } |
| } |
| registerFeature(DomainFeature); |
|
|
| const host = createScopedTestHost(); |
| const manager = host.app.accessor.get(IFeatureManager); |
| const views = [ |
| collectionViewOf(host.app, SessionModelContribution), |
| collectionViewOf(host.app, AgentModelContribution), |
| ]; |
| expect(views.map((view) => view.items)).toEqual([ |
| [sessionModel], |
| [agentModel], |
| ]); |
| expect(() => manager.provideUnit(ReplacementFeature)).toThrow( |
| "Agent model 'test-feature.agent-model' already has an active provider", |
| ); |
|
|
| await manager.unprovideUnit('domain-definitions'); |
| await host.app.instantiation.cascade.whenIdle(); |
| expect(views.every((view) => view.items.length === 0)).toBe(true); |
| expect(() => manager.provideUnit(ReplacementFeature)).not.toThrow(); |
| host.dispose(); |
| }); |
|
|
| it('rejects duplicate service contributions until the provider unloads', async () => { |
| class FirstFeature extends Feature { |
| static override readonly name = 'first-feature'; |
|
|
| constructor() { |
| super(); |
| this.contributeAgentService(IGreeter, GreeterService); |
| } |
| } |
| class SecondFeature extends Feature { |
| static override readonly name = 'second-feature'; |
|
|
| constructor() { |
| super(); |
| this.contributeAgentService(IGreeter, GreeterService); |
| } |
| } |
| registerFeature(FirstFeature); |
|
|
| const host = createScopedTestHost(); |
| const manager = host.app.accessor.get(IFeatureManager); |
| const agent = host.child(LifecycleScope.Agent, 'agent-1'); |
| const original = agent.accessor.get(IGreeter); |
| expect(() => manager.provideUnit(SecondFeature)).toThrow( |
| /Service test-feature-greeter is already contributed at scope agent/, |
| ); |
| expect(manager.units().map((unit) => unit.name)).toEqual(['first-feature']); |
| expect( |
| manager |
| .contributedServices() |
| .filter((entry) => entry.scope === LifecycleScope.Agent && entry.id === IGreeter), |
| ).toHaveLength(1); |
| expect(collectionViewOf(host.app, ScopeUnits(LifecycleScope.Agent)).items).toHaveLength(1); |
| expect(agent.accessor.get(IGreeter)).toBe(original); |
|
|
| await manager.unprovideUnit('first-feature'); |
| await host.app.instantiation.cascade.whenIdle(); |
| expect(() => manager.provideUnit(SecondFeature)).not.toThrow(); |
| expect(manager.units().map((unit) => unit.name)).toEqual(['second-feature']); |
| expect(agent.accessor.get(IGreeter).greet()).toBe('hi'); |
|
|
| host.dispose(); |
| }); |
|
|
| it('isolates equal service contributions between App roots', async () => { |
| class SharedFeature extends Feature { |
| static override readonly name = 'shared-feature'; |
|
|
| constructor() { |
| super(); |
| this.contributeAgentService(IGreeter, GreeterService); |
| } |
| } |
| registerFeature(SharedFeature); |
|
|
| const first = createScopedTestHost(); |
| const second = createScopedTestHost(); |
| const firstManager = first.app.accessor.get(IFeatureManager); |
| const secondManager = second.app.accessor.get(IFeatureManager); |
| const firstAgent = first.child(LifecycleScope.Agent, 'agent-1'); |
| const secondAgent = second.child(LifecycleScope.Agent, 'agent-1'); |
| expect(firstManager.contributedServices()).toHaveLength(1); |
| expect(secondManager.contributedServices()).toHaveLength(1); |
| expect(firstAgent.accessor.get(IGreeter)).not.toBe(secondAgent.accessor.get(IGreeter)); |
|
|
| await firstManager.unprovideUnit('shared-feature'); |
| await first.app.instantiation.cascade.whenIdle(); |
| expect(firstManager.contributedServices()).toHaveLength(0); |
| expect(secondManager.contributedServices()).toHaveLength(1); |
| expect(() => firstAgent.accessor.get(IGreeter)).toThrow(); |
| expect(secondAgent.accessor.get(IGreeter).greet()).toBe('hi'); |
|
|
| first.dispose(); |
| second.dispose(); |
| }); |
|
|
| it('materializes a per-scope class recipe contributed through contribute()', () => { |
| class SoloAgentUnit extends Service { |
| static override readonly name = 'solo-feature/agent'; |
|
|
| constructor() { |
| super(); |
| this.provide(IGreeter, GreeterService); |
| } |
| } |
| class SoloFeature extends Feature { |
| static override readonly name = 'solo-feature'; |
|
|
| constructor() { |
| super(); |
| this.contribute(ScopeUnits(LifecycleScope.Agent), SoloAgentUnit); |
| } |
| } |
| registerFeature(SoloFeature); |
|
|
| const host = createScopedTestHost(); |
| const agent = host.child(LifecycleScope.Agent, 'agent-1'); |
| expect(agent.accessor.get(IGreeter).greet()).toBe('hi'); |
| host.dispose(); |
| }); |
| }); |
|
|
