agentnet 0.1.15 → 0.1.17

package/examples/smartness/agents-smartness.yaml

@@ -5,6 +5,8 @@ metadata:
   name: entrypoint
   namespace: smartexample
 spec:
+  runner:
+    maxConversationLength: 100
   io:
     - type: NatsIO
       bindings:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentnet",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "type": "module",
   "description": "Agent library used by Smartness",
   "main": "src/index.js",

package/src/agent/agent-loader.js

@@ -287,6 +287,10 @@ function configureRunner(agentBuilder, runnerSpec) {
         agentBuilder._config.runner.maxRuns = runnerSpec.maxRuns;
     }
     
+    if (runnerSpec.maxConversationLength !== undefined) {
+        agentBuilder._config.runner.maxConversationLength = runnerSpec.maxConversationLength;
+    }
+    
     return agentBuilder;
 }
 

package/src/agent/agent.js

@@ -27,7 +27,8 @@ const DEFAULT_CONFIG = {
         apiVersion: "agentnet/v1alpha1" // Default API version
     },
     runner: { 
-        maxRuns: 10
+        maxRuns: 10,
+        maxConversationLength: 10
     }
 }
 
@@ -75,7 +76,8 @@ const AGENT_CONFIG_SCHEMA = {
         runner: {
             type: 'object',
             properties: {
-                maxRuns: { type: 'number' }
+                maxRuns: { type: 'number' },
+                maxConversationLength: { type: 'number' }
             }
         },
         on: { type: 'object' }
@@ -214,6 +216,13 @@ export function Agent() {
                 });
             }
             
+            validateType(config.runner.maxConversationLength, 'number', 'runner.maxConversationLength', 'agent_config');
+            if (config.runner.maxConversationLength <= 0) {
+                throw new ConfigurationError("runner.maxConversationLength must be greater than 0", { 
+                    maxConversationLength: config.runner.maxConversationLength 
+                });
+            }
+            
             logger.debug(`Agent ${config.metadata.name} configuration validated successfully`);
             
         } catch (error) {

package/src/agent/executor.js

@@ -200,7 +200,7 @@ export async function build(
 		
 		// Create the executor function
 		const executor = async function(state, contents, run = 0) {
-			logger.info(`Running agent ${agentName} (run ${run}/${maxRuns}), conversation length: ${contents.length}`);
+			logger.info(`Running agent ${agentName} (run ${run}/${maxRuns}), conversation length: ${contents.getRawConversation().length}`);
 			
 			// Emit run event
 			await emit(hooks, 'executorRun', {
@@ -222,7 +222,8 @@ export async function build(
 				});
 				
 				// Return the last message as the result
-				return contents[contents.length - 1];
+				const rawConversation = contents.getRawConversation();
+				return rawConversation[rawConversation.length - 1];
 			}
 			
 			try {

package/src/agent/runtime.js

@@ -2,6 +2,7 @@ import { build, makeToolsAndHandoffsMap } from "./executor.js"
 import { logger } from "../utils/logger.js"
 import { Response, SessionStore } from "../index.js"
 import { createAgentRuntime } from "../transport/index.js"
+import { Conversation } from "../utils/conversation.js"
 
 export async function AgentRuntime(agentConfig) {
     const {
@@ -72,7 +73,7 @@ export async function AgentRuntime(agentConfig) {
             // Load and merge session state and session data
             let storeState = {
                 state: {},
-                conversation: []
+                conversation: new Conversation()
             }
             if (store && sessionId) {
                 const sessionStore = new SessionStore(storeStateSessionId)
@@ -85,7 +86,7 @@ export async function AgentRuntime(agentConfig) {
                     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}`);                
+                logger.info(`Loaded session state for agent ${agentName} with session id ${storeStateSessionId}, current conversation length ${storeState.conversation.getRawConversation().length}`);                
             }
 
             const formattedInput = typeof content === 'string' ? content : JSON.stringify(content);
@@ -107,9 +108,9 @@ export async function AgentRuntime(agentConfig) {
                 await store.instance.connect()
                 sessionStore.setConversation(storeState.conversation)
                 sessionStore.setState(storeState.state)
-                sessionStore.trimConversation(10)
+                sessionStore.trimConversation(runner?.maxConversationLength || 10)
                 await sessionStore.dump(store.instance)
-                logger.info(`Dumped session state for agent ${agentName} with session id ${storeStateSessionId}, current conversation length ${storeState.conversation.length}`);                
+                logger.info(`Dumped session state for agent ${agentName} with session id ${storeStateSessionId}, current conversation length ${storeState.conversation.getRawConversation().length}`);                
             }
 
             // Before returning, remove _ from the state

package/src/llm/base.js

@@ -48,7 +48,7 @@ export class BaseLLM {
 
   /**
    * Add a user prompt to the conversation
-   * @param {Array|Conversation} conversation - The conversation history
+   * @param {Conversation} conversation - The conversation history
    * @param {string} formattedPrompt - The formatted user prompt
    * @returns {Promise<void>}
    */
@@ -57,17 +57,14 @@ export class BaseLLM {
       promptPreview: formattedPrompt.substring(0, 100)
     });
     
-    // Handle both raw array and Conversation object
-    if (conversation instanceof Conversation) {
-      // Subclasses should override this to add their specific format
-      // But we'll add a generic format by default
-      conversation.addUserMessage({
-        role: 'user',
-        content: formattedPrompt
-      });
-    }
-    // For array, we rely on subclass implementations
-    // Subclasses must implement appropriate conversation format
+    // conversation is now always a Conversation object
+    // Subclasses should override this to add their specific format
+    // But we'll add a generic format by default
+    conversation.addUserMessage({
+      role: 'user',
+      content: formattedPrompt
+    });
+    // Removed logic for plain arrays
   }
 
   /**

package/src/llm/gemini.js

@@ -43,12 +43,8 @@ class GeminiLLM extends BaseLLM {
   async callModel(llmClientConfig, context) {
     const { client, toolsAndHandoffsMap, conversation } = context;
     
-    // Get raw conversation if it's a Conversation object
-    const conversationArray = conversation instanceof Conversation
-      ? conversation.getRawConversation()
-      : conversation;
-      
-    const input = { ...llmClientConfig, contents: conversationArray };
+    // conversation is always a Conversation object
+    const input = { ...llmClientConfig, contents: conversation.getRawConversation() };
 
     // Configure tools if provided
     if (input.config !== undefined && input.tools !== undefined) {
@@ -60,7 +56,7 @@ class GeminiLLM extends BaseLLM {
 
     logger.debug('Calling Gemini model', { 
       model: input.model,
-      conversationLength: conversationArray.length,
+      conversationLength: conversation.getRawConversation().length,
       toolsCount: toolsAndHandoffsMap.tools.length
     });
     
@@ -95,7 +91,7 @@ class GeminiLLM extends BaseLLM {
    * 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} conversation - The conversation history
+   * @param {Conversation} conversation - The conversation history
    * @param {Object} toolsAndHandoffsMap - Map of available tools
    */
   async handleToolCall(toolCall, state, conversation, toolsAndHandoffsMap) {
@@ -105,7 +101,6 @@ class GeminiLLM extends BaseLLM {
     try {
       const result = await super.executeToolCall(toolCall, name, args, state, 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
@@ -114,16 +109,10 @@ class GeminiLLM extends BaseLLM {
       const functionCallMessage = { role: 'model', parts: [{ functionCall: toolCall }] };
       const functionResponseMessage = { role: 'user', parts: [{ functionResponse: function_response_part }] };
       
-      if (conversation instanceof Conversation) {
-        conversation.addFunctionCall(functionCallMessage);
-        conversation.addFunctionResult(functionResponseMessage);
-      } else {
-        conversation.push(functionCallMessage);
-        conversation.push(functionResponseMessage);
-      }
+      conversation.addFunctionCall(functionCallMessage);
+      conversation.addFunctionResult(functionResponseMessage);
       
     } catch (error) {
-      // Return error as function response in Gemini-specific format
       const errorResponse = {
         name: name,
         response: { error: error.message }
@@ -132,36 +121,28 @@ class GeminiLLM extends BaseLLM {
       const functionCallMessage = { role: 'model', parts: [{ functionCall: toolCall }] };
       const functionResponseMessage = { role: 'user', parts: [{ functionResponse: errorResponse }] };
       
-      if (conversation instanceof Conversation) {
-        conversation.addFunctionCall(functionCallMessage);
-        conversation.addFunctionResult(functionResponseMessage);
-      } else {
-        conversation.push(functionCallMessage);
-        conversation.push(functionResponseMessage);
-      }
+      conversation.addFunctionCall(functionCallMessage);
+      conversation.addFunctionResult(functionResponseMessage);
     }
   }
 
   /**
    * Processes the model response, handling text responses and function calls
    * @param {Object} state - Current application state
-   * @param {Array|Conversation} conversation - The conversation history
+   * @param {Conversation} 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
     logger.info('Gemini onResponse', {text: response.text !== undefined, functionCalls: response.functionCalls?.length });
 
     if (response.text !== undefined) {
-      if (conversation instanceof Conversation) {
-        const modelResponse = {
-          role: 'model',
-          parts: [{ text: response.text }]
-        };
-        conversation.addModelResponse(modelResponse);
-      }
+      const modelResponse = {
+        role: 'model',
+        parts: [{ text: response.text }]
+      };
+      conversation.addModelResponse(modelResponse);
     }
 
     if (response.text !== undefined && (response.functionCalls === undefined || response.functionCalls.length === 0)) {
@@ -186,23 +167,19 @@ class GeminiLLM extends BaseLLM {
 
   /**
    * Adds a user prompt to the conversation
-   * @param {Array|Conversation} conversation - The conversation history
+   * @param {Conversation} conversation - The conversation history
    * @param {string} formattedPrompt - The formatted user prompt
    * @returns {Promise<void>}
    */
   async prompt(conversation, formattedPrompt) {
-    await super.prompt(conversation, formattedPrompt);
+    // super.prompt(conversation, formattedPrompt); // Removed to avoid duplicate/conflicting user message addition
     
     const userMessage = {
       role: 'user',
       parts: [{ text: formattedPrompt }]
     };
     
-    if (conversation instanceof Conversation) {
-      conversation.addUserMessage(userMessage);
-    } else {
-      conversation.push(userMessage);
-    }
+    conversation.addUserMessage(userMessage);
   }
 }
 

package/src/llm/gpt.js

@@ -45,14 +45,12 @@ class OpenAILLM extends BaseLLM {
 		const input = { ...llmClientConfig };
 		input.tools = toolsAndHandoffsMap.tools;
 		
-		// Get raw conversation if it's a Conversation object
-		input.input = conversation instanceof Conversation
-			? conversation.getRawConversation()
-			: conversation;
+		// conversation is always a Conversation object
+		input.input = conversation.getRawConversation();
 		
 		logger.debug('Calling OpenAI model', { 
 			model: input.model,
-			conversationLength: input.input.length,
+			conversationLength: conversation.getRawConversation().length,
 			toolsCount: toolsAndHandoffsMap.tools.length
 		});
 		//console.log(JSON.stringify(input, null, 2))
@@ -81,7 +79,7 @@ class OpenAILLM extends BaseLLM {
 	 * 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} conversation - The conversation history
+	 * @param {Conversation} conversation - The conversation history
 	 * @param {Object} toolsAndHandoffsMap - Map of available tools
 	 */
 	async handleToolCall(toolCall, state, conversation, toolsAndHandoffsMap) {
@@ -98,11 +96,7 @@ class OpenAILLM extends BaseLLM {
 			const result = await super.executeToolCall(toolCall, name, args, state, toolsAndHandoffsMap);
 			
 			// Add function call to conversation
-			if (conversation instanceof Conversation) {
-				conversation.addFunctionCall(toolCall);
-			} else {
-				conversation.push(toolCall);
-			}
+			conversation.addFunctionCall(toolCall);
 			
 			const resultString = typeof result === 'string' ? result : JSON.stringify(result);
 			
@@ -118,40 +112,27 @@ class OpenAILLM extends BaseLLM {
 			};
 			
 			// Add function result to conversation
-			if (conversation instanceof Conversation) {
-				conversation.addFunctionResult(functionOutput);
-			} else {
-				conversation.push(functionOutput);
-			}
+			conversation.addFunctionResult(functionOutput);
 		} catch (error) {
 			logger.error(`Error executing tool "${toolCall.name}"`, { error });
 			
 			// Add error as function output
-			if (conversation instanceof Conversation) {
-				conversation.addFunctionCall(toolCall);
-				
-				const errorOutput = {
-					type: "function_call_output",
-					call_id: toolCall.call_id,
-					output: JSON.stringify({ error: error.message })
-				};
-				
-				conversation.addFunctionResult(errorOutput);
-			} else {
-				conversation.push(toolCall);
-				conversation.push({
-					type: "function_call_output",
-					call_id: toolCall.call_id,
-					output: JSON.stringify({ error: error.message })
-				});
-			}
+			conversation.addFunctionCall(toolCall);
+			
+			const errorOutput = {
+				type: "function_call_output",
+				call_id: toolCall.call_id,
+				output: JSON.stringify({ error: error.message })
+			};
+			
+			conversation.addFunctionResult(errorOutput);
 		}
 	}
 
 	/**
 	 * Processes the model response, handling text responses and function calls
 	 * @param {Object} state - Current application state
-	 * @param {Array|Conversation} conversation - The conversation history
+	 * @param {Conversation} 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
@@ -160,13 +141,11 @@ class OpenAILLM extends BaseLLM {
 		if (response.output_text !== undefined && response.output_text.length > 0 ) {
 			logger.debug('OpenAI response contains text, returning directly');
 			
-			// Add model response to conversation if using Conversation object
-			if (conversation instanceof Conversation) {
-				conversation.addModelResponse({
-					role: 'assistant',
-					content: response.output_text
-				});
-			}
+			// Add model response to conversation
+			conversation.addModelResponse({
+				role: 'assistant',
+				content: response.output_text
+			});
 			
 			return response.output_text;
 		}
@@ -181,11 +160,7 @@ class OpenAILLM extends BaseLLM {
 		
 		// Add reasoning to conversation
 		for (const res of reasoning) {
-			if (conversation instanceof Conversation) {
-				conversation.addModelResponse(res);
-			} else {
-				conversation.push(res);
-			}
+			conversation.addModelResponse(res);
 		}
 
 		// Process all tool calls sequentially
@@ -198,23 +173,12 @@ class OpenAILLM extends BaseLLM {
 
 	/**
 	 * Adds a user prompt to the conversation
-	 * @param {Array|Conversation} conversation - The conversation history
+	 * @param {Conversation} conversation - The conversation history
 	 * @param {string} formattedPrompt - The formatted user prompt
 	 * @returns {Promise<void>}
 	 */
 	async prompt(conversation, formattedPrompt) {
 		await super.prompt(conversation, formattedPrompt);
-		
-		const userMessage = {
-			role: 'user',
-			content: formattedPrompt
-		};
-		
-		if (conversation instanceof Conversation) {
-			conversation.addUserMessage(userMessage);
-		} else {
-			conversation.push(userMessage);
-		}
 	}
 }
 

package/src/store/store.js

@@ -9,7 +9,7 @@ export function session (id) {
 
 	return {
 		query: async function (agentInstance, input) {
-			return await agentInstance.query(state, conversationManager.getRawConversation(), input)
+			return await agentInstance.query(state, conversationManager, input)
 		},
 		setState: function (_state) {
 			state = _state
@@ -26,16 +26,15 @@ export function session (id) {
 			conversationManager.trim(elementsToKeep)
 		},
 		setConversation: function (_conversation) {
-			// Support both array and Conversation objects
 			if (_conversation instanceof Conversation) {
 				conversationManager = _conversation;
-			} else if (Array.isArray(_conversation)) {
-				conversationManager.importFromArray(_conversation);
+			} else {
+				console.warn("Attempted to set conversation with an invalid type. Expected a Conversation object.");
+				conversationManager = new Conversation();
 			}
 		},	
 		getConversation: function () {
-			// Return raw conversation for backward compatibility
-			return conversationManager.getRawConversation()
+			return conversationManager
 		},
 		getConversationManager: function() {
 			return conversationManager
@@ -48,26 +47,23 @@ export function session (id) {
 				// Handle both old-style conversation array and new-style serialized Conversation
 				if (parsedState.conversationData) {
 					conversationManager.deserialize(parsedState.conversationData)
-				} else if (Array.isArray(parsedState.conversation)) {
-					conversationManager.importFromArray(parsedState.conversation)
 				}
 				
 				state = parsedState.state || {}
 				return {
 					// Return raw conversation for backward compatibility
-					conversation: conversationManager.getRawConversation(),
+					conversation: conversationManager,
 					state: state
 				}
 			}
 			return {
-				conversation: [],
+				conversation: new Conversation(), // Ensure it's a Conversation object
 				state: {}
 			}
 		},
 		dump: async function (stateStore) {
 			return await stateStore.set(id, JSON.stringify({
-				// Keep conversation array for backward compatibility
-				conversation: conversationManager.getRawConversation(),
+				// Keep conversation array for backward compatibility - REMOVED
 				// Add serialized conversation data with metadata
 				conversationData: conversationManager.serialize(),
 				state: state