agentnet 0.0.1

package/src/agent/client.js

@@ -0,0 +1,14 @@
+import { Message, Response } from '../index.js'
+export function AgentClient() {
+    return {
+        queryAgent: async (agent, input) => {
+            return await agent.query(input)
+        },
+
+        queryIo: async (io, target, message) => {
+            const transport = await io.connect()
+            const response = await transport.request(target, message.serialize(), { timeout: 60000 })
+            return new Response(JSON.parse(response.string()))
+        }
+    }
+}

package/src/agent/executor.js

@@ -0,0 +1,320 @@
+import { logger } from '../utils/logger.js';
+import { 
+	ToolExecutionError, 
+	LLMError, 
+	TimeoutError,
+	withTimeout,
+	withRetry 
+} from '../errors/index.js';
+
+const DEFAULT_TOOL_TIMEOUT = 30000; // 30 seconds
+const DEFAULT_LLM_TIMEOUT = 60000;  // 60 seconds
+
+/**
+ * Emits an event to the hooks system if hooks are available
+ * @param {Object} hooks - Event hooks
+ * @param {string} event - Event name
+ * @param {Object} data - Event data
+ */
+async function emit(hooks, event, data) {
+	if (hooks === null) {
+		return;
+	}
+	
+	try {
+		hooks.emit(event, data);
+	} catch (error) {
+		logger.warn(`Error emitting ${event} event`, { error, data });
+	}
+}
+
+/**
+ * Builds the tools and handoffs map for the executor
+ * @param {Object} toolsAndHandoffsMap - Map to populate
+ * @param {Array} tools - Tool definitions
+ * @param {Array} handoffs - Handoff definitions
+ */
+export function makeToolsAndHandoffsMap(toolsAndHandoffsMap, tools, handoffs) {
+	if (!tools) {
+		return;
+	}
+	
+	try {
+		// Process tools
+		for (const tool of tools) {
+			if (!tool) {
+				logger.warn('Skipping undefined tool');
+				continue;
+			}
+			
+			if (!tool.schema) {
+				toolsAndHandoffsMap.tools.push(tool);
+				continue;
+			}
+			
+			// Add tool schema to tools list
+			toolsAndHandoffsMap.tools.push(tool.schema);
+			
+			// Map tool name to function
+			toolsAndHandoffsMap[tool.name] = {
+				function: tool.function,
+				type: 'tool'
+			};
+		}
+		
+		// Process handoffs (which may be a nested array)
+		if (handoffs && Array.isArray(handoffs)) {
+			const flatHandoffs = handoffs.flat().filter(Boolean);
+			
+			for (const handoff of flatHandoffs) {
+				if (!handoff || !handoff.schema || !handoff.name) {
+					logger.warn('Skipping invalid handoff definition', { handoff });
+					continue;
+				}
+				
+				// Add handoff schema to tools list
+				toolsAndHandoffsMap.tools.push(handoff.schema);
+				
+				// Map handoff name to function
+				toolsAndHandoffsMap[handoff.name] = {
+					function: handoff.function,
+					type: 'handoff'
+				};
+			}
+		}
+	} catch (error) {
+		logger.error('Error building tools and handoffs map', { error });
+		throw error;
+	}
+}
+
+/**
+ * Safely executes a tool or handoff function with timeout and error handling
+ * @param {Function} func - Tool/handoff function to execute
+ * @param {string} name - Tool/handoff name
+ * @param {string} type - 'tool' or 'handoff'
+ * @param {Object} state - Agent state
+ * @param {any} input - Tool/handoff input
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<any>} Tool execution result
+ */
+async function safeExecute(func, name, type, state, input, timeout = DEFAULT_TOOL_TIMEOUT) {
+	if (typeof func !== 'function') {
+		throw new ToolExecutionError(
+			`${type} "${name}" is not a function`,
+			name,
+			input
+		);
+	}
+	
+	try {
+		// Execute with timeout
+		return await withTimeout(
+			async () => {
+				try {
+					return await func(state, input);
+				} catch (error) {
+					throw new ToolExecutionError(
+						`Error executing ${type} "${name}": ${error.message}`,
+						name,
+						input,
+						error
+					);
+				}
+			},
+			timeout,
+			`${type} execution: ${name}`
+		);
+	} catch (error) {
+		// Log detailed error information
+		logger.error(`${type} execution error`, { 
+			error, 
+			toolName: name, 
+			inputSample: JSON.stringify(input).substring(0, 200) 
+		});
+		
+		// Ensure we always return a structured error
+		if (error instanceof ToolExecutionError || error instanceof TimeoutError) {
+			throw error;
+		}
+		
+		throw new ToolExecutionError(
+			`Error executing ${type} "${name}": ${error.message}`,
+			name,
+			input,
+			error
+		);
+	}
+}
+
+/**
+ * Builds an executor for agent execution
+ * @param {Object} toolsAndHandoffsMap - Map of tools and handoffs
+ * @param {Object} hooks - Event hooks
+ * @param {string} agentName - Agent name
+ * @param {Object} api - LLM API
+ * @param {Object} llmConfig - LLM configuration
+ * @param {Object} runner - Runner configuration
+ * @returns {Function} Executor function
+ */
+export async function build(
+	toolsAndHandoffsMap,
+	hooks, 
+	agentName, 
+	api, 
+	llmConfig, 
+	runner
+) {
+	const maxRuns = runner?.maxRuns || 10;
+	
+	try {
+		// Initialize LLM client
+		logger.info(`Initializing LLM client for agent ${agentName}`);
+		const client = await api.getClient();
+		
+		// Add safe execution methods to toolsAndHandoffsMap
+		toolsAndHandoffsMap.safeExecute = async (name, type, state, input, timeout) => {
+			const handler = toolsAndHandoffsMap[name];
+			if (!handler) {
+				throw new ToolExecutionError(
+					`${type} "${name}" not found`,
+					name,
+					input
+				);
+			}
+			
+			return await safeExecute(
+				handler.function,
+				name,
+				type, 
+				state, 
+				input, 
+				timeout || DEFAULT_TOOL_TIMEOUT
+			);
+		};
+		
+		// Create the executor function
+		const executor = async function(state, contents, run = 0) {
+			logger.info(`Running agent ${agentName} (run ${run}/${maxRuns}), conversation length: ${contents.length}`);
+			
+			// Emit run event
+			await emit(hooks, 'executorRun', {
+				agentName: agentName,
+				run: run,
+				state: state,
+				contents: contents
+			});
+			
+			// Check for max runs exceeded
+			if (run >= maxRuns) {
+				logger.warn(`Agent ${agentName} max runs reached: ${run}/${maxRuns}`);
+				
+				await emit(hooks, 'executorMaxRuns', {
+					agentName: agentName,
+					run: run,
+					state: state,
+					contents: contents
+				});
+				
+				// Return the last message as the result
+				return contents[contents.length - 1];
+			}
+			
+			try {
+				// Prepare input for LLM
+				const input = {
+					client: client,
+					toolsAndHandoffsMap: toolsAndHandoffsMap,
+					conversation: contents
+				};
+				
+				// Call LLM with timeout and retry
+				logger.debug(`Calling LLM for agent ${agentName}`);
+				
+				const response = await withRetry(
+					async () => {
+						try {
+							return await withTimeout(
+								async () => api.callModel(llmConfig, input),
+								llmConfig.timeout || DEFAULT_LLM_TIMEOUT,
+								`LLM call for ${agentName}`
+							);
+						} catch (error) {
+							if (error instanceof TimeoutError) {
+								throw error; // Let the retry handler deal with timeouts
+							}
+							
+							throw new LLMError(
+								`LLM API error: ${error.message}`,
+								api.type || 'unknown',
+								{ modelConfig: llmConfig }
+							);
+						}
+					},
+					{
+						maxRetries: 2,
+						onRetry: ({ attempt }) => {
+							logger.warn(`Retrying LLM call for agent ${agentName} (attempt ${attempt})`);
+						}
+					}
+				);
+				
+				logger.debug(`LLM response received for agent ${agentName}`);
+				
+				// Process the response
+				const finished = await api.onResponse(state, contents, toolsAndHandoffsMap, response);
+				
+				// If not finished, continue with the next run
+				if (finished == null) {
+					return await executor(state, contents, run + 1);
+				}
+				
+				// Emit end event
+				await emit(hooks, 'executorEnd', {
+					agentName: agentName,
+					run: run,
+					state: state,
+					contents: contents,
+					response: finished
+				});
+				
+				return finished;
+			} catch (error) {
+				logger.error(`Error in agent ${agentName} execution`, { 
+					error, 
+					run, 
+					maxRuns 
+				});
+				
+				// Emit error event
+				await emit(hooks, 'executorError', {
+					agentName: agentName,
+					run: run,
+					state: state,
+					contents: contents,
+					error: error
+				});
+				
+				// Add error message to conversation
+				contents.push({
+					role: 'system',
+					content: `Error: ${error.message}`
+				});
+				
+				// If we haven't hit max runs, try again
+				if (run < maxRuns - 1) {
+					logger.info(`Continuing after error in agent ${agentName}`);
+					return await executor(state, contents, run + 1);
+				}
+				
+				// We've reached max runs, return the error
+				throw error;
+			}
+		};
+		
+		return executor;
+	} catch (error) {
+		logger.error(`Failed to build executor for agent ${agentName}`, { error });
+		throw error;
+	}
+}

package/src/agent/runtime.js

@@ -0,0 +1,142 @@
+import { build, makeToolsAndHandoffsMap } from "./executor.js"
+import { NatsIOAgentRuntime } from "./runtimes/nats.js"
+import { logger } from "../utils/logger.js"
+import { Response, SessionStore } from "../index.js"
+
+export async function AgentRuntime(agentConfig) {
+    const {
+        toolsAndHandoffsMap,
+        hooks,
+        store,
+        metadata: { name: agentName },
+        llm: { api: llmApi, config: llmConfig },
+        runner,
+        toolsSchemas: tools,
+        handoffs,
+        io: ioInterfaces,
+        discoverySchemas,
+        on: { prompt, response }
+    } = agentConfig
+    
+    // Initialize IO runtime
+    const natsInterfaces = ioInterfaces.filter(x => x.type === 'NatsIO')
+    const { handleTask, discoveredAgents } = await NatsIOAgentRuntime(
+        agentName, 
+        natsInterfaces, 
+        discoverySchemas
+    )
+    
+    // Build executor
+    const executor = await build(
+        toolsAndHandoffsMap,
+        hooks,
+        agentName,
+        llmApi,
+        llmConfig,
+        runner
+    )
+
+    // Create task processing function
+    const taskFunction = async function(state, conversation, input) {
+        try {
+            // Update tools and handoffs map with discovered agents
+            makeToolsAndHandoffsMap(
+                toolsAndHandoffsMap, 
+                Object.values(tools), 
+                [handoffs, Object.values(discoveredAgents)]
+            )
+            
+            // Process the input
+            await llmApi.prompt(conversation, typeof input === 'string' ? input : JSON.stringify(input))
+            
+            // Execute and return result
+            return await executor(state, conversation)
+        } catch (error) {
+            console.error("Task execution error:", error)
+            return { error: "Failed to execute task", details: error.message }
+        }
+    }
+
+    const queryFunction = async function(message) {
+        try {
+            const content = message.getContent()
+            const session = message.getSession()
+            const sessionId = message.getSessionId()
+            const storeStateSessionId = agentName + "." + sessionId
+
+            // Load and merge session state and session data
+            let storeState = {
+                state: {},
+                conversation: []
+            }
+            if (store && sessionId) {
+                const sessionStore = new SessionStore(storeStateSessionId)
+                await store.instance.connect()
+                const _storeState = await sessionStore.load(store.instance)
+                for (const key of Object.keys(_storeState.state)) {
+                    storeState.state[key] = _storeState.state[key]
+                }
+                for (const key of Object.keys(session)) {
+                    storeState.state[key] = session[key]
+                }         
+                storeState.conversation = _storeState.conversation
+                logger.info(`Loaded session state for agent ${agentName} with session id ${storeStateSessionId}, current conversation length ${storeState.conversation.length}`);                
+            }
+
+            const formattedInput = typeof content === 'string' ? content : JSON.stringify(content);
+            
+            logger.debug(`Query to agent ${agentName}`, {
+                inputPreview: formattedInput.substring(0, 100)
+            });
+            
+            // Process input through prompt hook
+            const promptContent = await prompt(storeState.state, formattedInput);
+            
+            // Execute agent runtime
+            const result = await taskFunction(storeState.state, storeState.conversation, promptContent);
+
+            // Process result through response hook
+            const responseMessage = await response(storeState.state, storeState.conversation, result);
+            // Save session state and session data
+            if (store && sessionId) {
+                const sessionStore = new SessionStore(storeStateSessionId)
+                await store.instance.connect()
+                sessionStore.setConversation(storeState.conversation)
+                sessionStore.setState(storeState.state)
+                sessionStore.trimConversation(10)
+                await sessionStore.dump(store.instance)
+                logger.info(`Dumped session state for agent ${agentName} with session id ${storeStateSessionId}, current conversation length ${storeState.conversation.length}`);                
+            }
+
+            // Before returning, remove _ from the state
+            // Keep the removed keys and print the removed keys 
+            const removedKeys = []
+            for (const key of Object.keys(storeState.state)) {
+                if (key.startsWith('_')) {
+                    removedKeys.push(key)
+                    delete storeState.state[key]
+                }
+            }
+            if (removedKeys.length > 0) {
+                logger.info(`Removed keys from state for agent ${agentName}: ${removedKeys.join(', ')}`);
+            }
+
+            const responseFormatted = new Response({
+                content: responseMessage,
+                session: storeState.state
+            })
+            return responseFormatted;
+        } catch (error) {
+            logger.error(`Agent query execution error: ${error.message}`, {
+                agentName: agentName,
+                error
+            });
+            throw error;
+        }
+    }    
+
+    // Start handling tasks
+    handleTask(queryFunction) // queryFunction
+    
+    return queryFunction // queryFunction
+}