agentnet 0.0.1 → 0.0.3

package/src/llm/gemini.js

@@ -1,155 +1,175 @@
 import { GoogleGenAI } from '@google/genai'
 import { logger } from '../utils/logger.js'
 import { LLMError } from '../errors/index.js'
+import { BaseLLM } from './base.js'
 
-const type = 'gemini' 
+/**
+ * Gemini LLM implementation
+ */
+class GeminiLLM extends BaseLLM {
+  constructor() {
+    super('gemini');
+  }
 
-const getClient = async function () {
+  /**
+   * Initializes and returns a Gemini client
+   * @returns {Promise<GoogleGenAI>} The initialized Gemini client
+   * @throws {LLMError} If initialization fails
+   */
+  async getClient() {
+    this.checkApiKey('GEMINI_API_KEY');
+    
     try {
-        if (!process.env.GEMINI_API_KEY) {
-            throw new LLMError(
-                'GEMINI_API_KEY environment variable is not set',
-                'gemini'
-            );
-        }
-        
-        logger.debug('Initializing Gemini client');
-        return new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+      logger.debug('Initializing Gemini client');
+      return new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
     } catch (error) {
-        logger.error('Failed to initialize Gemini client', { error });
-        throw new LLMError(
-            `Failed to initialize Gemini client: ${error.message}`,
-            'gemini',
-            { originalError: error }
-        );
+      logger.error('Failed to initialize Gemini client', { error });
+      throw new LLMError(
+        `Failed to initialize Gemini client: ${error.message}`,
+        this.type,
+        { originalError: error }
+      );
     }
-}
+  }
 
-const callModel = async function (llmClientConfig, context) {
-    const client = context.client;
-    const toolsAndHandoffsMap = context.toolsAndHandoffsMap;
-    const conversation = context.conversation;
-    const input = {};
-    
-    Object.assign(input, llmClientConfig);
-    input['contents'] = conversation;
+  /**
+   * Calls the Gemini model with the provided configuration and context
+   * @param {Object} llmClientConfig - Configuration for the Gemini model
+   * @param {Object} context - Context containing client, tools map and conversation
+   * @returns {Promise<Object>} The model response
+   * @throws {LLMError} If the API call fails
+   */
+  async callModel(llmClientConfig, context) {
+    const { client, toolsAndHandoffsMap, conversation } = context;
+    const input = { ...llmClientConfig, contents: conversation };
 
+    // Configure tools if provided
     if (input.config !== undefined && input.tools !== undefined) {
-        input.config.tools = toolsAndHandoffsMap.tools;
+      input.config.tools = toolsAndHandoffsMap.tools;
     } else if (toolsAndHandoffsMap.tools.length > 0) {
-        if (input.config == undefined) {
-            input.config = {};
-        }
-        input.config.tools = [{ functionDeclarations: toolsAndHandoffsMap.tools }];
+      input.config = input.config || {};
+      input.config.tools = [{ functionDeclarations: toolsAndHandoffsMap.tools }];
     }
 
     logger.debug('Calling Gemini model', { 
-        model: input.model,
-        conversationLength: conversation.length,
-        toolsCount: toolsAndHandoffsMap.tools.length
+      model: input.model,
+      conversationLength: conversation.length,
+      toolsCount: toolsAndHandoffsMap.tools.length
     });
     
     try {
-        const res = await client.models.generateContent(input);
-        logger.debug('Gemini response received', {
-            responseType: res.response?.candidates ? 'candidates' : 'unknown',
-            hasContent: !!res.response?.candidates?.[0]?.content
-        });
-        return res;
+      const res = await client.models.generateContent(input);
+      logger.debug('Gemini response received', {
+        responseType: res.response?.candidates ? 'candidates' : 'unknown',
+        hasContent: !!res.response?.candidates?.[0]?.content
+      });
+      return res;
     } catch (error) {
-        logger.error('Gemini API error', { 
-            error,
-            modelName: input.model
-        });
-        
-        throw new LLMError(
-            `Gemini API error: ${error.message}`,
-            'gemini',
-            {
-                statusCode: error.status || error.statusCode,
-                modelName: input.model
-            }
-        );
+      logger.error('Gemini API error', { 
+        error,
+        modelName: input.model
+      });
+      
+      throw new LLMError(
+        `Gemini API error: ${error.message}`,
+        this.type,
+        {
+          statusCode: error.status || error.statusCode,
+          modelName: input.model
+        }
+      );
     }
-}
+  }
+
+  /**
+   * Handle a specific tool call from Gemini response
+   * @param {Object} toolCall - The tool call to process
+   * @param {Object} state - Current application state
+   * @param {Array} conversation - The conversation history
+   * @param {Object} toolsAndHandoffsMap - Map of available tools
+   */
+  async handleToolCall(toolCall, state, conversation, toolsAndHandoffsMap) {
+    const args = toolCall.args;
+    const name = toolCall.name;
+    
+    try {
+      const result = await super.executeToolCall(toolCall, name, args, state, conversation, toolsAndHandoffsMap);
+      
+      // Add function call and response to conversation in Gemini-specific format
+      const function_response_part = {
+        name: name,
+        response: typeof result === 'string' ? { answer: result } : result
+      };
+      
+      conversation.push({ role: 'model', parts: [{ functionCall: toolCall }] });
+      conversation.push({ role: 'user', parts: [{ functionResponse: function_response_part }] });
+      
+    } catch (error) {
+      // Return error as function response in Gemini-specific format
+      const errorResponse = {
+        name: name,
+        response: { error: error.message }
+      };
+      
+      conversation.push({ role: 'model', parts: [{ functionCall: toolCall }] });
+      conversation.push({ role: 'user', parts: [{ functionResponse: errorResponse }] });
+    }
+  }
 
-const onResponse = async function (state, conversation, toolsAndHandoffsMap, response) {
+  /**
+   * Processes the model response, handling text responses and function calls
+   * @param {Object} state - Current application state
+   * @param {Array} conversation - The conversation history
+   * @param {Object} toolsAndHandoffsMap - Map of available tools
+   * @param {Object} response - The model response to process
+   * @returns {Promise<string|null>} Text response or null if processing tool calls
+   */
+  async onResponse(state, conversation, toolsAndHandoffsMap, response) {
+    // Handle simple text response
     if (response.text !== undefined) {
-        logger.debug('Gemini response contains text, returning directly');
-        conversation.push({ role: 'model', parts: [{ text: response.text }] });
-        return response.text;
+      logger.debug('Gemini response contains text, returning directly');
+      conversation.push({ role: 'model', parts: [{ text: response.text }] });
+      return response.text;
     }
     
+    // Handle function calls
     logger.debug('Gemini response contains function calls', {
-        functionCallCount: response.functionCalls?.length || 0
+      functionCallCount: response.functionCalls?.length || 0
     });
     
-    for (const toolCall of response.functionCalls) {
-        const args = toolCall.args;
-        const name = toolCall.name;
-        
-        logger.debug('Executing tool from Gemini', { 
-            toolName: name,
-            argsPreview: JSON.stringify(args).substring(0, 100)
-        });
-        
-        try {
-            if (!toolsAndHandoffsMap[name] || !toolsAndHandoffsMap[name].function) {
-                throw new Error(`Tool "${name}" not found or has no function implementation`);
-            }
-            
-            let result = await toolsAndHandoffsMap[name].function(conversation, state, args);
-            if (toolsAndHandoffsMap[name].type === 'handoff') {
-                const resultParsed = JSON.parse(result)
-                // Update state with the result
-                if (resultParsed.session) {
-                    for (const key of Object.keys(resultParsed.session)) {
-                        state[key] = resultParsed.session[key]
-                    }
-                }
-            }
-            
-            const function_response_part = {
-                name: name,
-                response: typeof result === 'string' ? { answer: result } : result
-            };
-            
-            // Append function call and result of the function execution to contents
-            conversation.push({ role: 'model', parts: [{ functionCall: toolCall }] });
-            conversation.push({ role: 'user', parts: [{ functionResponse: function_response_part }] });
-            
-            logger.debug('Tool execution successful', { toolName: name });
-        } catch (error) {
-            logger.error(`Error executing tool "${name}"`, { error });
-            // Return error as function response
-            const errorResponse = {
-                name: name,
-                response: { error: error.message }
-            };
-            
-            conversation.push({ role: 'model', parts: [{ functionCall: toolCall }] });
-            conversation.push({ role: 'user', parts: [{ functionResponse: errorResponse }] });
-        }
+    // Process all tool calls sequentially
+    if (response.functionCalls?.length) {
+      for (const toolCall of response.functionCalls) {
+        await this.handleToolCall(toolCall, state, conversation, toolsAndHandoffsMap);
+      }
     }
     
     return null;
-}
+  }
 
-const prompt = async function (conversation, formattedPrompt) {
-    logger.debug('Adding user prompt to conversation', {
-        promptPreview: formattedPrompt.substring(0, 100)
-    });
+  /**
+   * Adds a user prompt to the conversation
+   * @param {Array} conversation - The conversation history
+   * @param {string} formattedPrompt - The formatted user prompt
+   * @returns {Promise<void>}
+   */
+  async prompt(conversation, formattedPrompt) {
+    await super.prompt(conversation, formattedPrompt);
     
     conversation.push({
-        role: 'user',
-        parts: [{ text: formattedPrompt}]
+      role: 'user',
+      parts: [{ text: formattedPrompt }]
     });
+  }
 }
 
+// Create a singleton instance
+const geminiLLM = new GeminiLLM();
+
 export default {
-    type,
-    getClient,
-    prompt,
-    callModel,
-    onResponse
+  type: geminiLLM.type,
+  getClient: geminiLLM.getClient.bind(geminiLLM),
+  prompt: geminiLLM.prompt.bind(geminiLLM),
+  callModel: geminiLLM.callModel.bind(geminiLLM),
+  onResponse: geminiLLM.onResponse.bind(geminiLLM)
 }

package/src/llm/gpt.js

@@ -1,89 +1,88 @@
 import OpenAI from 'openai'
 import { logger } from '../utils/logger.js'
 import { LLMError } from '../errors/index.js'
+import { BaseLLM } from './base.js'
 
-const type = 'openai' 
+/**
+ * OpenAI LLM implementation
+ */
+class OpenAILLM extends BaseLLM {
+	constructor() {
+		super('openai');
+	}
 
-const getClient = async function () {
-	try {
-		if (!process.env.OPENAI_API_KEY) {
+	/**
+	 * Initializes and returns an OpenAI client
+	 * @returns {Promise<OpenAI>} The initialized OpenAI client
+	 * @throws {LLMError} If initialization fails
+	 */
+	async getClient() {
+		this.checkApiKey('OPENAI_API_KEY');
+		
+		try {
+			logger.debug('Initializing OpenAI client');
+			return new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+		} catch (error) {
+			logger.error('Failed to initialize OpenAI client', { error });
 			throw new LLMError(
-				'OPENAI_API_KEY environment variable is not set',
-				'openai'
+				`Failed to initialize OpenAI client: ${error.message}`,
+				this.type,
+				{ originalError: error }
 			);
 		}
-		
-		logger.debug('Initializing OpenAI client');
-		return new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-	} catch (error) {
-		logger.error('Failed to initialize OpenAI client', { error });
-		throw new LLMError(
-			`Failed to initialize OpenAI client: ${error.message}`,
-			'openai',
-			{ originalError: error }
-		);
 	}
-}
 
-const callModel = async function (llmClientConfig, context) {
-	const client = context.client
-	const toolsAndHandoffsMap = context.toolsAndHandoffsMap
-	const conversation = context.conversation
-	const input = {}	
-	Object.assign(input, llmClientConfig)
-	input['tools'] = toolsAndHandoffsMap.tools
-	input['input'] = conversation
-	
-	logger.debug('Calling OpenAI model', { 
-		model: input.model,
-		conversationLength: conversation.length,
-		toolsCount: toolsAndHandoffsMap.tools.length
-	});
-	
-	try {
-		const response = await client.responses.create(input)
-		logger.debug('OpenAI response received');
-		return response
-	} catch (error) {
-		logger.error('OpenAI API error', { 
-			error,
-			modelName: input.model
+	/**
+	 * Calls the OpenAI model with the provided configuration and context
+	 * @param {Object} llmClientConfig - Configuration for the OpenAI model
+	 * @param {Object} context - Context containing client, tools map and conversation
+	 * @returns {Promise<Object>} The model response
+	 * @throws {LLMError} If the API call fails
+	 */
+	async callModel(llmClientConfig, context) {
+		const { client, toolsAndHandoffsMap, conversation } = context;
+		const input = { ...llmClientConfig };
+		input.tools = toolsAndHandoffsMap.tools;
+		input.input = conversation;
+		
+		logger.debug('Calling OpenAI model', { 
+			model: input.model,
+			conversationLength: conversation.length,
+			toolsCount: toolsAndHandoffsMap.tools.length
 		});
 		
-		throw new LLMError(
-			`OpenAI API error: ${error.message}`,
-			'openai',
-			{
-				statusCode: error.status || error.statusCode,
+		try {
+			const response = await client.responses.create(input);
+			logger.debug('OpenAI response received');
+			return response;
+		} catch (error) {
+			logger.error('OpenAI API error', { 
+				error,
 				modelName: input.model
-			}
-		);
-	}
-}
-
-const onResponse = async function (state, conversation, toolsAndHandoffsMap, response) {
-	if (response.output_text !== undefined && response.output_text.length > 0) {
-		logger.debug('OpenAI response contains text, returning directly');
-		conversation.push({ role: 'model', parts: [{ text: response.output_text }] });
-		return response.output_text
-	}
-
-	const reasoning = response.output.filter(x => x.type == 'reasoning')
-	const functionCalls = response.output.filter(x => x.type == 'function_call')
-	
-	logger.debug('OpenAI response processing', {
-		reasoningCount: reasoning.length,
-		functionCallCount: functionCalls.length
-	});
-	
-	for (const res of reasoning) {
-		conversation.push(res)
+			});
+			
+			throw new LLMError(
+				`OpenAI API error: ${error.message}`,
+				this.type,
+				{
+					statusCode: error.status || error.statusCode,
+					modelName: input.model
+				}
+			);
+		}
 	}
 
-	for (const toolCall of functionCalls) {
+	/**
+	 * Handle a specific tool call from OpenAI response
+	 * @param {Object} toolCall - The tool call to process
+	 * @param {Object} state - Current application state
+	 * @param {Array} conversation - The conversation history
+	 * @param {Object} toolsAndHandoffsMap - Map of available tools
+	 */
+	async handleToolCall(toolCall, state, conversation, toolsAndHandoffsMap) {
 		try {
-			const args = JSON.parse(toolCall.arguments)
-			const name = toolCall.name
+			const args = JSON.parse(toolCall.arguments);
+			const name = toolCall.name;
 			
 			logger.debug('Executing tool from OpenAI', { 
 				toolName: name,
@@ -91,24 +90,10 @@ const onResponse = async function (state, conversation, toolsAndHandoffsMap, res
 				callId: toolCall.call_id
 			});
 			
-			if (!toolsAndHandoffsMap[name] || !toolsAndHandoffsMap[name].function) {
-				throw new Error(`Tool "${name}" not found or has no function implementation`);
-			}
-			
-			let result = await toolsAndHandoffsMap[name].function(conversation, state, args)
-			conversation.push(toolCall)
-            if (toolsAndHandoffsMap[name].type === 'handoff') {
-                console.log("GPT HANDOFF onResponse", name, result)
-                const resultParsed = JSON.parse(result)
-                // Update state with the result
-                if (resultParsed.session) {
-                    for (const key of Object.keys(resultParsed.session)) {
-                        state[key] = resultParsed.session[key]
-                    }
-                }
-            }			
+			const result = await super.executeToolCall(toolCall, name, args, state, conversation, toolsAndHandoffsMap);
+			conversation.push(toolCall);
 			
-			const resultString = typeof result == 'string' ? result : JSON.stringify(result)
+			const resultString = typeof result === 'string' ? result : JSON.stringify(result);
 			
 			logger.debug('Tool execution successful', { 
 				toolName: name,
@@ -119,7 +104,7 @@ const onResponse = async function (state, conversation, toolsAndHandoffsMap, res
 				type: "function_call_output",
 				call_id: toolCall.call_id,
 				output: resultString
-			})
+			});
 		} catch (error) {
 			logger.error(`Error executing tool "${toolCall.name}"`, { error });
 			
@@ -132,24 +117,66 @@ const onResponse = async function (state, conversation, toolsAndHandoffsMap, res
 			});
 		}
 	}
-	return null
-}
 
-const prompt = async function (conversation, formattedPrompt) {
-	logger.debug('Adding user prompt to conversation', {
-		promptPreview: formattedPrompt.substring(0, 100)
-	});
-	
-	conversation.push({
-		role: 'user',
-		content: formattedPrompt
-	})
+	/**
+	 * Processes the model response, handling text responses and function calls
+	 * @param {Object} state - Current application state
+	 * @param {Array} conversation - The conversation history
+	 * @param {Object} toolsAndHandoffsMap - Map of available tools
+	 * @param {Object} response - The model response to process
+	 * @returns {Promise<string|null>} Text response or null if processing tool calls
+	 */
+	async onResponse(state, conversation, toolsAndHandoffsMap, response) {
+		if (response.output_text !== undefined && response.output_text.length > 0) {
+			logger.debug('OpenAI response contains text, returning directly');
+			conversation.push({ role: 'model', parts: [{ text: response.output_text }] });
+			return response.output_text;
+		}
+
+		const reasoning = response.output.filter(x => x.type === 'reasoning');
+		const functionCalls = response.output.filter(x => x.type === 'function_call');
+		
+		logger.debug('OpenAI response processing', {
+			reasoningCount: reasoning.length,
+			functionCallCount: functionCalls.length
+		});
+		
+		// Add reasoning to conversation
+		for (const res of reasoning) {
+			conversation.push(res);
+		}
+
+		// Process all tool calls sequentially
+		for (const toolCall of functionCalls) {
+			await this.handleToolCall(toolCall, state, conversation, toolsAndHandoffsMap);
+		}
+		
+		return null;
+	}
+
+	/**
+	 * Adds a user prompt to the conversation
+	 * @param {Array} conversation - The conversation history
+	 * @param {string} formattedPrompt - The formatted user prompt
+	 * @returns {Promise<void>}
+	 */
+	async prompt(conversation, formattedPrompt) {
+		await super.prompt(conversation, formattedPrompt);
+		
+		conversation.push({
+			role: 'user',
+			content: formattedPrompt
+		});
+	}
 }
 
+// Create a singleton instance
+const openaiLLM = new OpenAILLM();
+
 export default {
-	type,
-	getClient,
-	prompt,
-	callModel,
-	onResponse
+	type: openaiLLM.type,
+	getClient: openaiLLM.getClient.bind(openaiLLM),
+	prompt: openaiLLM.prompt.bind(openaiLLM),
+	callModel: openaiLLM.callModel.bind(openaiLLM),
+	onResponse: openaiLLM.onResponse.bind(openaiLLM)
 }