FilesExpand file tree

github

/

app.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

121 lines (111 loc) · 4.99 KB

github

/

app.ts

Copy path

Top

File metadata and controls

• Code
• Blame

121 lines (111 loc) · 4.99 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

import { AgentStateService } from '#agent/agentStateService/agentStateService';

import { FileAgentStateService } from '#agent/agentStateService/fileAgentStateService';

import { FirestoreAgentStateService } from '#agent/agentStateService/firestoreAgentStateService';

import { InMemoryAgentStateService } from '#agent/agentStateService/inMemoryAgentStateService';

import { RouteDefinition } from '#fastify/fastifyApp';

import { FirestoreLlmCallService } from '#llm/llmCallService/firestoreLlmCallService';

import { InMemoryLlmCallService } from '#llm/llmCallService/inMemoryLlmCallService';

import { LlmCallService } from '#llm/llmCallService/llmCallService';

import { logger } from '#o11y/logger';

import { FileUserService } from '#user/userService/fileUserService';

import { FirestoreUserService } from '#user/userService/firestoreUserService';

import { InMemoryUserService } from '#user/userService/inMemoryUserService';

import { UserService } from '#user/userService/userService';

import { FileFunctionCacheService } from './cache/fileFunctionCacheService';

import { FirestoreCacheService } from './cache/firestoreFunctionCacheService';

import { FunctionCacheService } from './cache/functionCacheService';

import { TypeBoxFastifyInstance, initFastify } from './fastify';

import { functionRegistry } from './functionRegistry';

import { agentDetailsRoutes } from './routes/agent/agent-details-routes';

import { agentExecutionRoutes } from './routes/agent/agent-execution-routes';

import { agentStartRoute } from './routes/agent/agent-start-route';

import { gitlabRoutesV1 } from './routes/gitlab/gitlabRoutes-v1';

import { llmCallRoutes } from './routes/llms/llm-call-routes';

import { llmRoutes } from './routes/llms/llm-routes';

import { profileRoute } from './routes/profile/profile-route';

export interface ApplicationContext {

agentStateService: AgentStateService;

userService: UserService;

llmCallService: LlmCallService;

functionCacheService: FunctionCacheService;

}

export interface AppFastifyInstance extends TypeBoxFastifyInstance, ApplicationContext {}

let applicationContext: ApplicationContext;

// Ensures the functions are registered

functionRegistry();

/**

* @return the main application context

*/

export function appContext(): ApplicationContext {

// Default to in-memory so unit tests don't initialise every time

applicationContext ??= initInMemoryApplicationContext();

return applicationContext;

}

/**

* Creates the applications services and starts the Fastify server.

*/

export async function initApp(): Promise<void> {

// If the process has the argument --db=file, or DATABASE=file env var, then use file based persistence

const args = process.argv.slice(2); // Remove the first two elements (node and script path)

const dbArg = args.find((arg) => arg.startsWith('--db='));

const database = process.env.DATABASE;

if (dbArg?.slice(5) === 'file' || database === 'file') {

await initFileApplicationContext();

} else if (database === 'memory') {

initInMemoryApplicationContext();

} else if (database === 'firestore') {

await initFirestoreApplicationContext();

} else {

throw new Error(`Invalid value for DATABASE environment: ${database}`);

}

try {

await initFastify({

routes: [

gitlabRoutesV1 as RouteDefinition,

agentStartRoute as RouteDefinition,

agentDetailsRoutes as RouteDefinition,

agentExecutionRoutes as RouteDefinition,

profileRoute as RouteDefinition,

llmRoutes as RouteDefinition,

llmCallRoutes as RouteDefinition,

// Add your routes below this line

],

instanceDecorators: applicationContext, // This makes all properties on the ApplicationContext interface available on the fastify instance in the routes

requestDecorators: {},

});

} catch (err: any) {

logger.fatal(err, 'Could not start nous');

}

}

export async function initFirestoreApplicationContext(): Promise<ApplicationContext> {

logger.info('Initializing Firestore persistence');

applicationContext = {

agentStateService: new FirestoreAgentStateService(),

userService: new FirestoreUserService(),

llmCallService: new FirestoreLlmCallService(),

functionCacheService: new FirestoreCacheService(),

};

await applicationContext.userService.ensureSingleUser();

return applicationContext;

}

export async function initFileApplicationContext(): Promise<ApplicationContext> {

logger.info('Initializing file based persistence');

applicationContext = {

agentStateService: new FileAgentStateService(),

userService: new FileUserService(),

llmCallService: new InMemoryLlmCallService(),

functionCacheService: new FileFunctionCacheService(),

};

await applicationContext.userService.ensureSingleUser();

return applicationContext;

}

export function initInMemoryApplicationContext(): ApplicationContext {

applicationContext = {

agentStateService: new InMemoryAgentStateService(),

userService: new InMemoryUserService(),

llmCallService: new InMemoryLlmCallService(),

functionCacheService: new FileFunctionCacheService(),

};

applicationContext.userService.ensureSingleUser().catch();

return applicationContext;

}