FilesExpand file tree

 main

/

usage.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

175 lines (158 loc) · 5.46 KB

 main

/

usage.ts

Top

File metadata and controls

• Code
• Blame

175 lines (158 loc) · 5.46 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

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

/**

* examples/usage.ts

*

* This file demonstrates the basic usage of the Agent Name Service (ANS).

* It shows how to:

* - Initialize the ANS service

* - Register multiple agents with different capabilities

* - Resolve agents in both A2A and MCP formats

* - Review threat analysis results

*

* Run with --quiet flag to suppress verbose logging:

* npx ts-node examples/usage.ts --quiet

*/

import { AgentNamingService } from '../src/ans';

import { suppressVerboseLogging, restoreConsoleLogging } from './utils/quiet-logging';

// Check if quiet mode is enabled via command line argument

const quietMode = process.argv.includes('--quiet');

// Helper function to print formatted outputs

function printSection(title: string, content: any) {

console.log('\n' + '='.repeat(80));

console.log(`${title}`);

console.log('='.repeat(80));

if (typeof content === 'object') {

console.log(JSON.stringify(content, null, 2));

} else {

console.log(content);

}

}

async function demonstrateANS() {

// Apply quiet logging if requested

if (quietMode) {

suppressVerboseLogging();

console.log("Running in quiet mode - verbose logs suppressed\n");

}

// Initialize the Agent Naming Service

const ans = new AgentNamingService();

printSection('Agent Name Service Initialized', 'Service ready to register and resolve agents');

// Example 1: Register a content generation agent

console.log('\n[Example 1] Registering a content generation agent...');

const contentAgent = await ans.registerAgent('content-creator-agent', {

version: '1.0.0',

capabilities: ['text-generation', 'summarization', 'translation'],

description: 'AI agent that creates and transforms content',

provider: 'OpenAI',

model: 'gpt-4',

endpoints: [

{

protocol: 'https',

address: 'api.contentcreator.ai',

port: 443

}

]

});

printSection('Content Generation Agent Registration Result', contentAgent.agentCard);

printSection('Threat Analysis Report', contentAgent.threatReport);

// Example 2: Register a data processing agent

console.log('\n[Example 2] Registering a data processing agent...');

const dataAgent = await ans.registerAgent('data-processor-agent', {

version: '2.1.0',

capabilities: ['data-extraction', 'data-transformation', 'analysis'],

description: 'Processes and analyzes structured and unstructured data',

provider: 'DataCorp',

model: 'data-processor-v2',

endpoints: [

{

protocol: 'https',

address: 'api.datacorp.com',

port: 443

}

],

rateLimit: {

requestsPerMinute: 60,

burstLimit: 10

}

});

printSection('Data Processing Agent Registration Result', dataAgent.agentCard);

printSection('Threat Analysis Report', dataAgent.threatReport);

// Example 3: Register a security agent with potentially suspicious capabilities

console.log('\n[Example 3] Registering a security agent (with suspicious capabilities)...');

const securityAgent = await ans.registerAgent('security-admin-agent', {

version: '1.0.0',

capabilities: ['system-monitoring', 'threat-detection', 'exploit-research'],

description: 'Monitors systems for security threats and vulnerabilities',

provider: 'SecureDefense',

model: 'security-defender-v1',

endpoints: [

{

protocol: 'https',

address: 'api.securedefense.com',

port: 443

}

],

permissions: ['file-system-access', 'network-monitoring', 'execute-scripts']

});

printSection('Security Agent Registration Result', securityAgent.agentCard);

printSection('Threat Analysis Report', securityAgent.threatReport);

// Example 4: Resolve an agent

console.log('\n[Example 4] Resolving an agent by name...');

const resolvedAgent = await ans.resolveAgent('content-creator-agent');

printSection('Resolved Agent', resolvedAgent);

// Example 5: Generate MCP manifest

console.log('\n[Example 5] Generating MCP manifest for data processing agent...');

const mcpManifest = ans.generateMCPManifest('data-processor-agent', {

tools: [

{

name: 'extract_data',

description: 'Extract structured data from documents',

parameters: {

document_url: {

type: 'string',

description: 'URL of the document to process'

},

output_format: {

type: 'string',

enum: ['json', 'csv', 'xml'],

default: 'json'

}

}

},

{

name: 'analyze_data',

description: 'Perform statistical analysis on datasets',

parameters: {

data_source: {

type: 'string',

description: 'Data source URL or identifier'

},

analysis_type: {

type: 'string',

enum: ['descriptive', 'predictive', 'prescriptive'],

default: 'descriptive'

}

}

}

],

authentication: {

type: 'oauth2',

scopes: ['data:read', 'data:write']

}

});

printSection('MCP Manifest', mcpManifest);

// Restore console logging if it was suppressed

if (quietMode) {

restoreConsoleLogging();

console.log("Verbose logging restored");

}

}

// Execute the demonstration

demonstrateANS()

.then(() => {

console.log('\nDemonstration completed successfully!');

// Force process to exit since there are timers in AgentNamingService

process.exit(0);

})

.catch(error => {

console.error('Error in ANS demonstration:', error);

process.exit(1);

});