@minded-ai/mindedjs 1.0.98 → 1.0.99

package/docs/platform/parallel-llm.md

@@ -0,0 +1,242 @@
+# Parallel LLM Requests
+
+Parallel LLM requests can significantly reduce latency by sending multiple identical requests and using the fastest response. This feature can reduce response times by 30-50% in scenarios with variable network conditions.
+
+## Quick Start
+
+The easiest way to enable parallel requests is through your `minded.json` configuration:
+
+```json
+{
+  "flows": ["./src/flows"],
+  "tools": ["./src/tools"],
+  "agent": "./src/agent.ts",
+  "llm": {
+    "name": "MindedChatOpenAI",
+    "properties": {
+      "model": "gpt-4o",
+      "numParallelRequests": 3,
+      "logTimings": true
+    }
+  }
+}
+```
+
+Your agent will automatically use parallel requests for all LLM calls:
+
+```typescript
+import { Agent } from '@minded-ai/mindedjs';
+import memorySchema from './agentMemorySchema';
+import config from '../minded.json';
+import tools from './tools';
+
+const agent = new Agent({
+  memorySchema,
+  config, // Parallel configuration is automatically applied
+  tools,
+});
+```
+
+## Configuration Options
+
+### MindedChatOpenAI (Recommended)
+
+For agents running on the Minded platform, use `MindedChatOpenAI` with parallel configuration:
+
+```json
+{
+  "llm": {
+    "name": "MindedChatOpenAI",
+    "properties": {
+      "model": "gpt-4o",
+      "numParallelRequests": 3,
+      "logTimings": true,
+      "temperature": 0.7
+    }
+  }
+}
+```
+
+### AzureChatOpenAI
+
+For Azure OpenAI deployments:
+
+```json
+{
+  "llm": {
+    "name": "AzureChatOpenAI",
+    "properties": {
+      "model": "gpt-4o",
+      "numParallelRequests": 3,
+      "logTimings": true,
+      "azureOpenAIApiVersion": "2024-02-01"
+    }
+  }
+}
+```
+
+Required environment variables:
+
+```env
+AZURE_OPENAI_API_KEY=your_azure_key
+AZURE_OPENAI_API_INSTANCE_NAME=your_instance_name
+AZURE_OPENAI_API_DEPLOYMENT_NAME=your_deployment_name
+```
+
+### ChatOpenAI
+
+For standard OpenAI API:
+
+```json
+{
+  "llm": {
+    "name": "ChatOpenAI",
+    "properties": {
+      "model": "gpt-4o",
+      "numParallelRequests": 3,
+      "logTimings": true,
+      "openAIApiKey": "${OPENAI_API_KEY}"
+    }
+  }
+}
+```
+
+## Configuration Parameters
+
+| Parameter             | Type    | Default | Description                                   |
+| --------------------- | ------- | ------- | --------------------------------------------- |
+| `numParallelRequests` | number  | 1       | Number of parallel requests (2-5 recommended) |
+| `logTimings`          | boolean | false   | Enable detailed timing logs                   |
+
+## Performance Notes
+
+- **Optimal Range**: 2-3 parallel requests usually provide the best latency/cost balance
+- **Cost Impact**: You pay for all parallel requests made
+- **Best Use Cases**: Variable network conditions, consistency requirements
+- **Latency Reduction**: Typically 30-50% faster response times
+
+## Monitoring Performance
+
+When `logTimings: true` is enabled, you'll see detailed performance logs:
+
+```
+[Model] Fastest request completed { requestTime: 1.234, numParallelRequests: 3 }
+[Model] Time saved using parallel requests {
+  fastestRequestTime: 1.234,
+  secondFastestRequestTime: 1.567,
+  allFinishTime: 2.345,
+  timeSaved: 1.111,
+  timeSavedFromSecond: 0.333
+}
+```
+
+## Advanced Usage
+
+### Dynamic Configuration
+
+You can adjust parallel requests based on environment:
+
+```json
+{
+  "llm": {
+    "name": "MindedChatOpenAI",
+    "properties": {
+      "model": "gpt-4o",
+      "numParallelRequests": "${NODE_ENV === 'production' ? 3 : 1}",
+      "logTimings": "${NODE_ENV === 'development'}"
+    }
+  }
+}
+```
+
+### Manual Instantiation with createParallelWrapper
+
+For advanced use cases where you need direct control over the LLM instance, you can manually apply parallel wrapping:
+
+```typescript
+import { createParallelWrapper } from '@minded-ai/mindedjs';
+import { ChatOpenAI, AzureChatOpenAI } from '@langchain/openai';
+
+// Manual wrapping for ChatOpenAI
+const parallelOpenAI = createParallelWrapper(
+  new ChatOpenAI({
+    openAIApiKey: process.env.OPENAI_API_KEY,
+    model: 'gpt-4o',
+    temperature: 0.7,
+  }),
+  {
+    numParallelRequests: 3,
+    logTimings: true,
+  },
+);
+
+// Manual wrapping for AzureChatOpenAI
+const parallelAzure = createParallelWrapper(
+  new AzureChatOpenAI({
+    azureOpenAIApiKey: process.env.AZURE_OPENAI_API_KEY,
+    azureOpenAIApiInstanceName: process.env.AZURE_OPENAI_INSTANCE!,
+    azureOpenAIApiDeploymentName: process.env.AZURE_OPENAI_DEPLOYMENT!,
+    azureOpenAIApiVersion: '2024-02-01',
+  }),
+  {
+    numParallelRequests: 2,
+    logTimings: false,
+  },
+);
+
+// Use directly with Agent (bypassing configuration)
+const agent = new Agent({
+  memorySchema,
+  config: {
+    flows: ['./flows'],
+    tools: [],
+    llm: parallelOpenAI as any, // Direct LLM instance
+  },
+  tools: [],
+});
+```
+
+**Note**: The configuration-based approach is recommended for most use cases as it's simpler and more maintainable. Use manual instantiation only when you need specific control over LLM creation or are integrating with existing LangChain workflows.
+
+## How It Works
+
+### MindedChatOpenAI (Backend Processing)
+
+- Parallel requests are handled on the Minded platform backend
+- Multiple requests sent to Azure OpenAI from the backend
+- Fastest response returned to your agent
+- Optimal for production deployments
+
+### Other LLM Providers (Client-Side Processing)
+
+- Parallel requests handled in your application
+- Multiple requests sent directly to the LLM provider
+- Good for development and custom deployments
+
+## Best Practices
+
+1. **Start Small**: Begin with 2-3 parallel requests
+2. **Monitor Costs**: Each parallel request counts toward your usage
+3. **Enable Logging**: Use `logTimings: true` during development to measure improvements
+4. **Environment-Specific**: Use fewer parallel requests in development
+5. **Configuration Over Code**: Prefer `minded.json` configuration over manual instantiation
+
+## Troubleshooting
+
+### No Performance Improvement
+
+- Check network latency variability
+- Ensure `numParallelRequests > 1`
+- Verify timing logs are showing multiple requests
+
+### Increased Costs
+
+- Reduce `numParallelRequests`
+- Consider cost vs. latency trade-offs
+- Monitor usage patterns
+
+### Rate Limiting
+
+- Lower `numParallelRequests`
+- Implement backoff strategies
+- Contact provider about rate limits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minded-ai/mindedjs",
-  "version": "1.0.98",
+  "version": "1.0.99",
   "description": "MindedJS is a TypeScript library for building agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -66,4 +66,4 @@
     "uuid": "^11.1.0",
     "ws": "^8.15.1"
   }
-}
+}

package/src/agent.ts

@@ -447,7 +447,7 @@ export class Agent {
           const handlerResult = results.find((r) => r !== undefined);
           if (handlerResult) {
             if (!handlerResult.isQualified) {
-              logger.info(`Trigger ${triggerName} was disqualified`);
+              logger.debug({ msg: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
               return;
             }
             memoryUpdate = handlerResult.memory || {};
@@ -457,7 +457,7 @@ export class Agent {
         }
       }
 
-      logger.info({ message: 'Invoking trigger', triggerName, sessionId, triggerBody });
+      logger.info({ msg: '[Trigger] Received', triggerName, triggerBody, sessionId });
       const langraphConfig = this.getLangraphConfig(sessionId || uuidv4());
       const state = await this.compiledGraph.getState(langraphConfig);
       const suffixes = Object.values(internalNodesSuffix);
@@ -510,7 +510,7 @@ export class Agent {
       return res;
     } catch (error: any) {
       logger.error({
-        message: 'Invoke error',
+        msg: '[Trigger] Error',
         errorMessage: error.message,
         stack: error.stack,
         sessionId,
@@ -744,7 +744,7 @@ export class Agent {
     // Skip secret loading in local development
     const { runLocally } = getConfig();
     if (runLocally) {
-      logger.info('Running locally - skipping secret loading');
+      logger.debug({ msg: '[Agent] Secrets loaded from local .env file' });
       return {};
     }
     if (!mindedConnection.isConnected()) {
@@ -771,10 +771,10 @@ export class Agent {
       const secrets = response.secrets || {};
 
       // Load secrets into process.env
-      logger.debug(`Loading ${Object.keys(secrets).length} secrets into environment variables`);
       Object.entries(secrets).forEach(([key, value]) => {
         process.env[key] = value;
       });
+      logger.debug(`[Agent] Loaded ${Object.keys(secrets).length} secrets from platform`);
 
       // Cache the secrets for future requests
       this.secretsCache = secrets;
@@ -790,7 +790,7 @@ export class Agent {
   }
 
   private setupVoice(): void {
-    logger.info('Setting up voice');
+    logger.info('[Voice] Setting up voice');
     if (!mindedConnection.isConnected()) {
       throw new Error('Minded connection is required');
     }
@@ -813,7 +813,7 @@ export class Agent {
           voiceSession.sendAudio(audioMessage.audioData);
         } else {
           logger.trace({
-            message: 'Audio received; voice session not found for sessionId',
+            message: '[Voice] Audio received; voice session not found for sessionId',
             sessionId: audioMessage.sessionId,
             activeSessions: Array.from(this.voiceSessions.keys()),
           });
@@ -823,13 +823,13 @@ export class Agent {
       // Hangup / end session handler
       connection.on(mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_END, (message) => {
         const hangup = message as BaseVoiceMessage;
-        logger.debug({ message: 'Dashboard eneded voice session', sessionId: hangup.sessionId });
+        logger.debug({ message: '[Voice] Dashboard eneded voice session', sessionId: hangup.sessionId });
         const voiceSession = this.voiceSessions.get(hangup.sessionId);
         if (voiceSession) {
           voiceSession.hangup();
         } else {
           logger.trace({
-            message: 'Session ended; voice session not found for sessionId',
+            message: '[Voice] Session ended; voice session not found for sessionId',
             sessionId: hangup.sessionId,
             activeSessions: this.voiceSessions.keys(),
           });
@@ -856,7 +856,7 @@ export class Agent {
       voiceId: voiceTrigger.voiceId,
     });
     await voiceSession.init();
-    logger.debug({ message: 'Voice session initialized', sessionId: params.sessionId });
+    logger.debug({ message: '[Voice] Voice session initialized', sessionId: params.sessionId });
     this.voiceSessions.set(params.sessionId, voiceSession);
 
     // Emit voice session start event
@@ -884,7 +884,7 @@ export class Agent {
    To be used by the Lambda wrapper to restore checkpoints
   */
   public async restoreCheckpoint(sessionId: string, checkpointId: string): Promise<void> {
-    logger.info({ message: 'Restoring checkpoint', sessionId, checkpointId });
+    logger.info({ msg: '[Agent]Restoring checkpoint', sessionId, checkpointId });
     const langraphConfig = this.getLangraphConfig(sessionId, checkpointId);
     await this.compiledGraph.invoke(
       new Command({

package/src/checkpointer/checkpointSaverFactory.ts

@@ -13,6 +13,6 @@ export function createCheckpointSaver(): BaseCheckpointSaver {
     return new MemorySaver();
   }
 
-  logger.debug('Using remote checkpoint saver');
+  logger.debug('[Agent] Using remote checkpoint saver');
   return new MindedCheckpointSaver();
 }

package/src/edges/createDirectEdge.ts

@@ -10,8 +10,7 @@ export const createDirectEdge = (edge: StepForwardEdge) => {
     }
     // For direct edges, we just return the target of the first edge
     // since there's no conditional logic needed
-    logger.info(`Executing edge ${JSON.stringify(edge)}`);
-
+    logger.info({ msg: `[Router] Direct edge`, target: edge.target });
     return edge.target;
   };
 };

package/src/edges/createLogicalRouter.ts

@@ -8,7 +8,7 @@ const CONDITION_TIMEOUT = 5000; // 5 seconds
 
 export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.debug(`Evaluating logical conditions for ${edges.length} edges`);
+    logger.debug({ msg: `[Router] Evaluating logical conditions for ${edges.length} edges` });
 
     if (state.goto) {
       console.log('Jumping to node', state.goto);
@@ -64,7 +64,16 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         ]);
 
         if (result === true) {
-          logger.info(`Condition matched for edge ${edge.source} → ${edge.target}`);
+          if (edge.source == edge.target) {
+            logger.info({ msg: `[Router] Stay at node ${edge.source}`, node: edge.source, condition: edge.condition });
+          } else {
+            logger.info({
+              msg: `[Router] Logical condition matched`,
+              transitionFrom: edge.source,
+              transitionTo: edge.target,
+              condition: edge.condition,
+            });
+          }
           return edge.target;
         }
       } catch (error) {
@@ -73,7 +82,7 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         const conditionPreview = edge.condition.length > 100 ? `${edge.condition.substring(0, 100)}...` : edge.condition;
 
         logger.error({
-          msg: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
+          msg: `[Router] Error evaluating condition for edge ${edge.source} → ${edge.target}`,
           condition: conditionPreview,
           error: errorMessage,
           edgeIndex: edges.indexOf(edge),
@@ -88,15 +97,18 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
 
     // If no regular conditions matched, check for "else" conditions
     if (elseEdges.length > 0) {
-      logger.info(`No regular conditions matched, evaluating ${elseEdges.length} else condition(s)`);
       // Return the first "else" condition's target
       const elseEdge = elseEdges[0];
-      logger.info(`Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`);
+      logger.info({
+        msg: `[Router] Else condition matched`,
+        transitionFrom: elseEdge.source,
+        transitionTo: elseEdge.target,
+      });
       return elseEdge.target;
     }
 
     // If no conditions matched or all failed, return to the source node
-    logger.info('No conditions matched');
+    logger.info({ msg: `[Router] Stay at node ${edges[0].source}, no conditions matched`, node: edges[0].source });
     return null;
   };
 };

package/src/edges/createPromptRouter.ts

@@ -70,7 +70,7 @@ export const createPromptRouter = ({
   currentNodeName?: string;
 }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt router. Edges: ${JSON.stringify(edges)}`);
+    logger.debug({ msg: `[Router] Executing prompt router`, edges: JSON.stringify(edges) });
 
     if (state.goto) {
       console.log('Jumping to node', state.goto);
@@ -79,7 +79,10 @@ export const createPromptRouter = ({
 
     // If canStayInCurrentNode is true and there are no edges, return current node immediately
     if (canStayInCurrentNode && edges.length === 0 && currentNodeName) {
-      logger.info(`No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}`);
+      logger.info({
+        msg: `[Router] Stay at node, No edges available and canStayInCurrentNode==true`,
+        node: currentNodeName,
+      });
       return currentNodeName;
     }
 
@@ -179,13 +182,13 @@ export const createPromptRouter = ({
 
         const decision = validatedResponse.nextNodeId === currentNodeName ? 'stay in current node' : validatedResponse.nextNodeId;
         const reasoning = includeReasoning && 'reasoning' in validatedResponse ? ` - Reasoning: ${validatedResponse.reasoning}` : '';
-        logger.info({ msg: `Router decision: ${decision}`, reasoning });
+        logger.debug({ msg: `[Router] Decision: ${decision}`, reasoning });
 
         return validatedResponse.nextNodeId;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         logger.warn({
-          message: `Prompt router attempt ${attempts} failed`,
+          msg: `[Router] Prompt router attempt ${attempts} failed`,
           error: lastError.message,
           attempt: attempts,
           maxRetries,
@@ -195,7 +198,7 @@ export const createPromptRouter = ({
           // If all retries failed, return the first available edge as fallback
           const fallbackNode = edges[0]?.target;
           logger.error({
-            message: 'Prompt router reached max retries, using fallback',
+            msg: '[Router] Prompt router reached max retries, using fallback',
             fallbackNode,
             lastError: lastError.message,
           });

package/src/index.ts

@@ -7,6 +7,12 @@ import { resetTimer, cancelTimer, onTimer } from './internalTools/timer';
 export type { ElevenLabsContext } from './types/Voice.types';
 export { Agent, events, logger, sendPlaceholderMessage, resetTimer, cancelTimer, onTimer };
 
+// Export LLM implementations
+export { MindedChatOpenAI } from './platform/models/mindedChatOpenAI';
+export { createParallelWrapper } from './platform/models/parallelWrapper';
+export type { MindedChatOpenAIFields, BaseParallelChatFields } from './platform/models/mindedChatOpenAI';
+export type { BaseParallelChatFields as ParallelWrapperFields } from './platform/models/parallelWrapper';
+
 // HTTP module for PII masking - only public API
 export type { PIIGatewayInstance, HttpRequestConfig, HttpResponse } from './platform/piiGateway';
 

package/src/llm/createLlmInstance.ts

@@ -1,4 +1,5 @@
-import { LLMConfig, LLMProviders, LLMProvider } from "../types/LLM.types";
+import { LLMConfig, LLMProviders, LLMProvider } from '../types/LLM.types';
+import { createParallelWrapper, BaseParallelChatFields } from '../platform/models/parallelWrapper';
 
 export const createLlmInstance = (llmConfig: LLMConfig) => {
   const { name, properties } = llmConfig;
@@ -6,5 +7,27 @@ export const createLlmInstance = (llmConfig: LLMConfig) => {
   if (!LLMClass) {
     throw new Error(`Unsupported LLM provider: ${name}`);
   }
-  return new LLMClass(properties);
+
+  // Create the base LLM instance
+  const llmInstance = new LLMClass(properties);
+
+  // Check if parallel configuration is present
+  const hasParallelConfig = properties.numParallelRequests && properties.numParallelRequests > 1;
+
+  // For MindedChatOpenAI, parallel functionality is handled on the backend
+  if (name === 'MindedChatOpenAI') {
+    return llmInstance;
+  }
+
+  // For other LLM providers, apply client-side parallel wrapper if configured
+  if (hasParallelConfig) {
+    const parallelOptions: BaseParallelChatFields = {
+      numParallelRequests: properties.numParallelRequests,
+      logTimings: properties.logTimings,
+    };
+
+    return createParallelWrapper(llmInstance, parallelOptions);
+  }
+
+  return llmInstance;
 };

package/src/nodes/addAppToolNode.ts

@@ -26,14 +26,14 @@ export const addAppToolNode = async ({
   const cleanedParameters = Object.fromEntries(Object.entries(node.parameters || {}).filter(([, value]) => value !== ''));
   const appRunnerTool = getAppActionRunnerTool(node.displayName!);
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing tool node ${appRunnerTool.name}`);
+    logger.debug({ msg: `[Node] Executing tool node`, node: appRunnerTool.name });
 
     const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
       try {
         const response = await appRunnerTool.execute({ input, state, agent });
         return response || {};
       } catch (error) {
-        logger.error({ msg: 'Error executing tool', error });
+        logger.error({ msg: `[Node] Error executing tool`, error, node: node.name });
         throw error;
       }
     };

package/src/nodes/addBrowserTaskNode.ts

@@ -17,7 +17,7 @@ type AddBrowserTaskNodeParams = {
 
 export const addBrowserTaskNode = async ({ graph, node, agent }: AddBrowserTaskNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing browser task node ${node.displayName}`, prompt: node.prompt });
+    logger.info({ msg: `Executing browser task node ${node.displayName}`, prompt: node.prompt });
 
     const prompt = `
     # Task instructions:\n${node.prompt}\n\n
@@ -42,14 +42,20 @@ export const addBrowserTaskNode = async ({ graph, node, agent }: AddBrowserTaskN
       additional_kwargs: {
         mindedMetadata: {
           nodeType: NodeType.BROWSER_TASK,
-        }
+        },
       },
     });
     try {
-      const result = await executeBrowserTask(`Follow the instructions. Any retrieved data should be printed as string and not saved to a file.\n${node.prompt}`);
-      await agent.compiledGraph.updateState(agent.getLangraphConfig(state.sessionId), {
-        messages: [toolCallingMessage],
-      }, node.name);
+      const result = await executeBrowserTask(
+        `Follow the instructions. Any retrieved data should be printed as string and not saved to a file.\n${node.prompt}`,
+      );
+      await agent.compiledGraph.updateState(
+        agent.getLangraphConfig(state.sessionId),
+        {
+          messages: [toolCallingMessage],
+        },
+        node.name,
+      );
       logger.debug({ message: 'Browser task result', result });
       const toolCall = new ToolMessage({
         id: uuidv4(),
@@ -62,7 +68,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent }: AddBrowserTaskN
         additional_kwargs: {
           mindedMetadata: {
             nodeType: NodeType.BROWSER_TASK,
-          }
+          },
         },
       });
       return {
@@ -80,7 +86,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent }: AddBrowserTaskN
       const toolCall = new ToolMessage({
         id: uuidv4(),
         content: JSON.stringify({
-          error: error instanceof Error ? error.message : error.toString()
+          error: error instanceof Error ? error.message : error.toString(),
         }),
         status: 'error',
         name: 'browser-task',
@@ -88,7 +94,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent }: AddBrowserTaskN
         additional_kwargs: {
           mindedMetadata: {
             nodeType: NodeType.BROWSER_TASK,
-          }
+          },
         },
       });
       return {
@@ -100,7 +106,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent }: AddBrowserTaskN
           messageIds: [toolCallingMessageId],
         }),
         messages: [toolCallingMessage, toolCall],
-      }
+      };
     }
   };
   graph.addNode(node.name, callback);

package/src/nodes/addHumanInTheLoopNode.ts

@@ -13,7 +13,7 @@ export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${i
 
 export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
+    logger.debug({ msg: `[Node] Waiting for human input`, node: attachedToNodeName });
 
     if (state.messages[state.messages.length - 1].getType() === 'ai') {
       const value = interrupt('input from human in the loop');

package/src/nodes/addPromptNode.ts

@@ -26,7 +26,7 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt node ${node.name}`);
+    logger.debug({ msg: `[Node] Executing prompt node`, node: node.displayName });
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -61,11 +61,12 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
 
       for (const toolCall of result.tool_calls) {
         const matchedTool = globalTools.find((t) => t.name === toolCall.name);
-        logger.info({ msg: `Model called tool ${matchedTool?.name}` });
+        logger.info({ msg: `[Model] Calling tool`, tool: matchedTool?.name });
         if (matchedTool) {
           try {
             // Invoke the LangChain tool directly
             const toolResult = await matchedTool.invoke(toolCall);
+            logger.debug({ msg: `[Tool] Tool result`, tool: matchedTool?.name, result: toolResult });
             const toolStateUpdate = extractToolStateResponse(toolResult);
             // Properly merge memory and other state updates
             stateUpdates = {
@@ -75,7 +76,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
             };
             toolResults.push(toolResult);
           } catch (error) {
-            logger.error({ msg: `Error executing tool ${toolCall.name}:`, error });
+            logger.error({ msg: `[Tool] Error executing tool`, tool: toolCall.name, error });
             const errorMessage = new ToolMessage({
               content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
               tool_call_id: toolCall.id!,
@@ -83,7 +84,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
             toolResults.push(errorMessage);
           }
         } else {
-          logger.error({ msg: `Model tried to call tool ${toolCall.name} but it was not found` });
+          logger.error({ msg: `[Tool] Model called tool but it was not found`, tool: toolCall.name });
         }
       }
 
@@ -99,7 +100,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         message: result.content as string,
         state,
       });
-      console.log('AI Message', result.content);
+      logger.info({ msg: `[Model] Response`, content: result.content });
     }
 
     return {