@agentforge/patterns 0.15.9 → 0.15.11

package/dist/index.cjs

@@ -273,10 +273,12 @@ function formatScratchpad(scratchpad) {
   }).join("\n\n");
 }
 
-// src/react/nodes.ts
-var import_messages = require("@langchain/core/messages");
+// src/react/nodes/reasoning.ts
 var import_core3 = require("@agentforge/core");
 
+// src/react/nodes/shared.ts
+var import_messages = require("@langchain/core/messages");
+
 // src/shared/deduplication.ts
 var import_core2 = require("@agentforge/core");
 function normalizeObject(obj) {
@@ -321,76 +323,114 @@ function buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, totalObserv
   };
 }
 
-// src/shared/error-handling.ts
-function isGraphInterrupt(error) {
-  return error !== null && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt";
+// src/react/nodes/shared.ts
+var reasoningLogger = createPatternLogger("agentforge:patterns:react:reasoning");
+var actionLogger = createPatternLogger("agentforge:patterns:react:action");
+var observationLogger = createPatternLogger("agentforge:patterns:react:observation");
+function normalizeConversationMessage(message) {
+  switch (message.role) {
+    case "user":
+      return new import_messages.HumanMessage(message.content);
+    case "assistant":
+      return new import_messages.AIMessage(message.content);
+    case "system":
+      return new import_messages.SystemMessage(message.content);
+    case "tool":
+      if (!message.tool_call_id) {
+        reasoningLogger.warn(
+          "Tool message missing tool_call_id; falling back to human message",
+          message.name ? { name: message.name } : void 0
+        );
+        return new import_messages.HumanMessage(message.content);
+      }
+      return new import_messages.ToolMessage({
+        content: message.content,
+        tool_call_id: message.tool_call_id,
+        name: message.name
+      });
+    default:
+      return new import_messages.HumanMessage(message.content);
+  }
 }
-function handleNodeError(error, context, verbose = false) {
-  if (isGraphInterrupt(error)) {
-    throw error;
+function buildReasoningMessages(systemPrompt, stateMessages, scratchpad) {
+  const messages = [
+    new import_messages.SystemMessage(systemPrompt),
+    ...stateMessages.map(normalizeConversationMessage)
+  ];
+  if (scratchpad.length > 0) {
+    messages.push(new import_messages.SystemMessage(`Previous steps:
+${formatScratchpad(scratchpad)}`));
   }
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  if (verbose) {
-    console.error(`[${context}] Error:`, errorMessage);
-    if (error instanceof Error && error.stack) {
-      console.error(`[${context}] Stack:`, error.stack);
+  return messages;
+}
+function extractToolCalls(response) {
+  if (!response.tool_calls || response.tool_calls.length === 0) {
+    return [];
+  }
+  return response.tool_calls.map((toolCall) => ({
+    id: toolCall.id || `call_${Date.now()}_${Math.random()}`,
+    name: toolCall.name,
+    arguments: toolCall.args ?? {},
+    timestamp: Date.now()
+  }));
+}
+function formatObservationContent(observation) {
+  if (observation.error) {
+    return `Error: ${observation.error}`;
+  }
+  return stringifyObservationResult(observation.result, 2);
+}
+function formatActionSummary(actions) {
+  return actions.map((action) => `${action.name}(${stringifyActionArguments(action.arguments)})`).join(", ");
+}
+function formatObservationSummary(observations) {
+  return observations.map((observation) => {
+    if (observation.error) {
+      return `Error: ${observation.error}`;
     }
+    return stringifyObservationResult(observation.result);
+  }).join("; ");
+}
+function stringifyObservationResult(result, space) {
+  if (typeof result === "string") {
+    return result;
+  }
+  try {
+    const stringified = JSON.stringify(result, null, space);
+    return stringified ?? String(result);
+  } catch {
+    return String(result);
+  }
+}
+function stringifyActionArguments(arguments_) {
+  return stringifyObservationResult(arguments_);
+}
+function getLatestThought(thoughts) {
+  return thoughts[thoughts.length - 1]?.content ?? "";
+}
+function debugIfVerbose(logger4, verbose, message, data) {
+  if (verbose) {
+    logger4.debug(message, data);
   }
-  return errorMessage;
 }
 
-// src/react/nodes.ts
-var reasoningLogger = createPatternLogger("agentforge:patterns:react:reasoning");
-var actionLogger = createPatternLogger("agentforge:patterns:react:action");
-var observationLogger = createPatternLogger("agentforge:patterns:react:observation");
+// src/react/nodes/reasoning.ts
 function createReasoningNode(llm, tools, systemPrompt, maxIterations, verbose = false) {
   const langchainTools = (0, import_core3.toLangChainTools)(tools);
   const llmWithTools = llm.bindTools ? llm.bindTools(langchainTools) : llm;
   return async (state) => {
     const currentIteration = state.iteration || 0;
     const startTime = Date.now();
-    reasoningLogger.debug("Reasoning iteration started", {
+    debugIfVerbose(reasoningLogger, verbose, "Reasoning iteration started", {
       iteration: currentIteration + 1,
       maxIterations,
-      observationCount: state.observations?.length || 0,
-      hasActions: !!state.actions?.length
+      observationCount: state.observations.length,
+      hasActions: state.actions.length > 0
     });
-    const stateMessages = state.messages || [];
-    const messages = [
-      new import_messages.SystemMessage(systemPrompt),
-      ...stateMessages.map((msg) => {
-        if (msg.role === "user") return new import_messages.HumanMessage(msg.content);
-        if (msg.role === "assistant") return new import_messages.AIMessage(msg.content);
-        if (msg.role === "system") return new import_messages.SystemMessage(msg.content);
-        if (msg.role === "tool") {
-          return new import_messages.ToolMessage({
-            content: msg.content,
-            tool_call_id: msg.tool_call_id,
-            name: msg.name
-          });
-        }
-        return new import_messages.HumanMessage(msg.content);
-      })
-    ];
-    const scratchpad = state.scratchpad || [];
-    if (scratchpad.length > 0) {
-      const scratchpadText = formatScratchpad(scratchpad);
-      messages.push(new import_messages.SystemMessage(`Previous steps:
-${scratchpadText}`));
-    }
+    const messages = buildReasoningMessages(systemPrompt, state.messages, state.scratchpad);
     const response = await llmWithTools.invoke(messages);
     const thought = typeof response.content === "string" ? response.content : "";
-    const toolCalls = [];
-    if (response.tool_calls && response.tool_calls.length > 0) {
-      for (const toolCall of response.tool_calls) {
-        toolCalls.push({
-          id: toolCall.id || `call_${Date.now()}_${Math.random()}`,
-          name: toolCall.name,
-          arguments: toolCall.args || {},
-          timestamp: Date.now()
-        });
-      }
-    }
+    const toolCalls = extractToolCalls(response);
     const shouldContinue = toolCalls.length > 0 && currentIteration + 1 < maxIterations;
     reasoningLogger.info("Reasoning complete", {
       iteration: currentIteration + 1,
@@ -405,21 +445,49 @@ ${scratchpadText}`));
       thoughts: thought ? [{ content: thought, timestamp: Date.now() }] : [],
       actions: toolCalls,
       iteration: 1,
-      // Add 1 to iteration counter (uses additive reducer)
       shouldContinue,
       response: toolCalls.length === 0 ? thought : void 0
-      // Final response if no tool calls
     };
   };
 }
+
+// src/shared/error-handling.ts
+function isGraphInterrupt(error) {
+  return error !== null && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt";
+}
+function handleNodeError(error, context, verbose = false) {
+  if (isGraphInterrupt(error)) {
+    throw error;
+  }
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (verbose) {
+    console.error(`[${context}] Error:`, errorMessage);
+    if (error instanceof Error && error.stack) {
+      console.error(`[${context}] Stack:`, error.stack);
+    }
+  }
+  return errorMessage;
+}
+
+// src/react/nodes/action.ts
 function createActionNode(tools, verbose = false, enableDeduplication = true) {
   const toolMap = new Map(tools.map((tool) => [tool.metadata.name, tool]));
+  function buildCacheKey(toolName, args) {
+    try {
+      return generateToolCallCacheKey(toolName, args);
+    } catch {
+      debugIfVerbose(actionLogger, verbose, "Skipping deduplication for unserializable tool call", {
+        toolName
+      });
+      return void 0;
+    }
+  }
   return async (state) => {
-    const actions = state.actions || [];
-    const allObservations = state.observations || [];
+    const actions = state.actions;
+    const allObservations = state.observations;
     const iteration = state.iteration || 0;
     const startTime = Date.now();
-    actionLogger.debug("Action node started", {
+    debugIfVerbose(actionLogger, verbose, "Action node started", {
       actionCount: actions.length,
       iteration,
       cacheEnabled: enableDeduplication
@@ -427,18 +495,27 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
     const recentActions = actions.slice(-10);
     const observations = [];
     const executionCache = /* @__PURE__ */ new Map();
+    const actionsById = new Map(actions.map((action) => [action.id, action]));
+    const observedToolCallIds = new Set(
+      allObservations.map((observation) => observation.toolCallId)
+    );
     let cacheSize = 0;
     if (enableDeduplication) {
       for (const observation of allObservations) {
-        const correspondingAction = actions.find((a) => a.id === observation.toolCallId);
+        const correspondingAction = actionsById.get(observation.toolCallId);
         if (correspondingAction) {
-          const cacheKey = generateToolCallCacheKey(correspondingAction.name, correspondingAction.arguments);
-          executionCache.set(cacheKey, observation);
-          cacheSize++;
+          const cacheKey = buildCacheKey(
+            correspondingAction.name,
+            correspondingAction.arguments
+          );
+          if (cacheKey) {
+            executionCache.set(cacheKey, observation);
+            cacheSize++;
+          }
         }
       }
       if (cacheSize > 0) {
-        actionLogger.debug("Deduplication cache built", {
+        debugIfVerbose(actionLogger, verbose, "Deduplication cache built", {
           cacheSize,
           totalObservations: allObservations.length
         });
@@ -447,9 +524,8 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
     let duplicatesSkipped = 0;
     let toolsExecuted = 0;
     for (const action of recentActions) {
-      const existingObservation = allObservations.find((obs) => obs.toolCallId === action.id);
-      if (existingObservation) {
-        actionLogger.debug("Skipping already-processed action", {
+      if (observedToolCallIds.has(action.id)) {
+        debugIfVerbose(actionLogger, verbose, "Skipping already-processed action", {
           toolName: action.name,
           toolCallId: action.id,
           iteration
@@ -457,13 +533,13 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
         continue;
       }
       if (enableDeduplication) {
-        const cacheKey = generateToolCallCacheKey(action.name, action.arguments);
-        const cachedResult = executionCache.get(cacheKey);
+        const cacheKey = buildCacheKey(action.name, action.arguments);
+        const cachedResult = cacheKey ? executionCache.get(cacheKey) : void 0;
         if (cachedResult) {
           duplicatesSkipped++;
           actionLogger.info("Duplicate tool call prevented", {
             toolName: action.name,
-            arguments: action.arguments,
+            argumentKeys: Object.keys(action.arguments),
             iteration,
             cacheHit: true
           });
@@ -488,11 +564,11 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
         continue;
       }
       try {
-        const startTime2 = Date.now();
+        const toolStartTime = Date.now();
         const result = await tool.invoke(action.arguments);
-        const executionTime = Date.now() - startTime2;
+        const executionTime = Date.now() - toolStartTime;
         toolsExecuted++;
-        actionLogger.debug("Tool executed successfully", {
+        debugIfVerbose(actionLogger, verbose, "Tool executed successfully", {
           toolName: action.name,
           executionTime,
           iteration
@@ -504,11 +580,13 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
         };
         observations.push(observation);
         if (enableDeduplication) {
-          const cacheKey = generateToolCallCacheKey(action.name, action.arguments);
-          executionCache.set(cacheKey, observation);
+          const cacheKey = buildCacheKey(action.name, action.arguments);
+          if (cacheKey) {
+            executionCache.set(cacheKey, observation);
+          }
         }
       } catch (error) {
-        const errorMessage = handleNodeError(error, `action:${action.name}`, false);
+        const errorMessage = handleNodeError(error, `action:${action.name}`, verbose);
         actionLogger.error("Tool execution failed", {
           toolName: action.name,
           error: errorMessage,
@@ -523,7 +601,11 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
       }
     }
     if (duplicatesSkipped > 0 || toolsExecuted > 0) {
-      const metrics = buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, observations.length);
+      const metrics = buildDeduplicationMetrics(
+        toolsExecuted,
+        duplicatesSkipped,
+        observations.length
+      );
       actionLogger.info("Action node complete", {
         iteration,
         ...metrics,
@@ -535,41 +617,37 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
     };
   };
 }
+
+// src/react/nodes/observation.ts
 function createObservationNode(verbose = false, returnIntermediateSteps = false) {
   return async (state) => {
-    const observations = state.observations || [];
-    const thoughts = state.thoughts || [];
-    const actions = state.actions || [];
+    const observations = state.observations;
+    const thoughts = state.thoughts;
+    const actions = state.actions;
     const iteration = state.iteration || 0;
-    observationLogger.debug("Processing observations", {
+    debugIfVerbose(observationLogger, verbose, "Processing observations", {
       observationCount: observations.length,
       iteration
     });
     const recentObservations = observations.slice(-10);
     const latestActions = actions.slice(-10);
-    const observationMessages = recentObservations.map((obs) => {
-      const content = obs.error ? `Error: ${obs.error}` : typeof obs.result === "string" ? obs.result : JSON.stringify(obs.result, null, 2);
-      return {
-        role: "tool",
-        content,
-        name: latestActions.find((a) => a.id === obs.toolCallId)?.name,
-        tool_call_id: obs.toolCallId
-        // Include tool_call_id for proper ToolMessage construction
-      };
-    });
-    const scratchpadEntries = returnIntermediateSteps ? [{
-      step: state.iteration,
-      thought: thoughts[thoughts.length - 1]?.content || "",
-      action: latestActions.map((a) => `${a.name}(${JSON.stringify(a.arguments)})`).join(", "),
-      observation: recentObservations.map((obs) => {
-        if (obs.error) {
-          return `Error: ${obs.error}`;
-        }
-        return typeof obs.result === "string" ? obs.result : JSON.stringify(obs.result);
-      }).join("; "),
-      timestamp: Date.now()
-    }] : [];
-    observationLogger.debug("Observation node complete", {
+    const actionNamesById = new Map(latestActions.map((action) => [action.id, action.name]));
+    const observationMessages = recentObservations.map((observation) => ({
+      role: "tool",
+      content: formatObservationContent(observation),
+      name: actionNamesById.get(observation.toolCallId),
+      tool_call_id: observation.toolCallId
+    }));
+    const scratchpadEntries = returnIntermediateSteps ? [
+      {
+        step: iteration,
+        thought: getLatestThought(thoughts),
+        action: formatActionSummary(latestActions),
+        observation: formatObservationSummary(recentObservations),
+        timestamp: Date.now()
+      }
+    ] : [];
+    debugIfVerbose(observationLogger, verbose, "Observation node complete", {
       iteration,
       scratchpadUpdated: returnIntermediateSteps,
       messageCount: observationMessages.length

package/dist/index.js

@@ -170,10 +170,17 @@ function formatScratchpad(scratchpad) {
   }).join("\n\n");
 }
 
-// src/react/nodes.ts
-import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+// src/react/nodes/reasoning.ts
 import { toLangChainTools } from "@agentforge/core";
 
+// src/react/nodes/shared.ts
+import {
+  HumanMessage,
+  AIMessage,
+  SystemMessage,
+  ToolMessage
+} from "@langchain/core/messages";
+
 // src/shared/deduplication.ts
 import { createLogger } from "@agentforge/core";
 function normalizeObject(obj) {
@@ -218,76 +225,114 @@ function buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, totalObserv
   };
 }
 
-// src/shared/error-handling.ts
-function isGraphInterrupt(error) {
-  return error !== null && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt";
+// src/react/nodes/shared.ts
+var reasoningLogger = createPatternLogger("agentforge:patterns:react:reasoning");
+var actionLogger = createPatternLogger("agentforge:patterns:react:action");
+var observationLogger = createPatternLogger("agentforge:patterns:react:observation");
+function normalizeConversationMessage(message) {
+  switch (message.role) {
+    case "user":
+      return new HumanMessage(message.content);
+    case "assistant":
+      return new AIMessage(message.content);
+    case "system":
+      return new SystemMessage(message.content);
+    case "tool":
+      if (!message.tool_call_id) {
+        reasoningLogger.warn(
+          "Tool message missing tool_call_id; falling back to human message",
+          message.name ? { name: message.name } : void 0
+        );
+        return new HumanMessage(message.content);
+      }
+      return new ToolMessage({
+        content: message.content,
+        tool_call_id: message.tool_call_id,
+        name: message.name
+      });
+    default:
+      return new HumanMessage(message.content);
+  }
 }
-function handleNodeError(error, context, verbose = false) {
-  if (isGraphInterrupt(error)) {
-    throw error;
+function buildReasoningMessages(systemPrompt, stateMessages, scratchpad) {
+  const messages = [
+    new SystemMessage(systemPrompt),
+    ...stateMessages.map(normalizeConversationMessage)
+  ];
+  if (scratchpad.length > 0) {
+    messages.push(new SystemMessage(`Previous steps:
+${formatScratchpad(scratchpad)}`));
   }
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  if (verbose) {
-    console.error(`[${context}] Error:`, errorMessage);
-    if (error instanceof Error && error.stack) {
-      console.error(`[${context}] Stack:`, error.stack);
+  return messages;
+}
+function extractToolCalls(response) {
+  if (!response.tool_calls || response.tool_calls.length === 0) {
+    return [];
+  }
+  return response.tool_calls.map((toolCall) => ({
+    id: toolCall.id || `call_${Date.now()}_${Math.random()}`,
+    name: toolCall.name,
+    arguments: toolCall.args ?? {},
+    timestamp: Date.now()
+  }));
+}
+function formatObservationContent(observation) {
+  if (observation.error) {
+    return `Error: ${observation.error}`;
+  }
+  return stringifyObservationResult(observation.result, 2);
+}
+function formatActionSummary(actions) {
+  return actions.map((action) => `${action.name}(${stringifyActionArguments(action.arguments)})`).join(", ");
+}
+function formatObservationSummary(observations) {
+  return observations.map((observation) => {
+    if (observation.error) {
+      return `Error: ${observation.error}`;
     }
+    return stringifyObservationResult(observation.result);
+  }).join("; ");
+}
+function stringifyObservationResult(result, space) {
+  if (typeof result === "string") {
+    return result;
+  }
+  try {
+    const stringified = JSON.stringify(result, null, space);
+    return stringified ?? String(result);
+  } catch {
+    return String(result);
+  }
+}
+function stringifyActionArguments(arguments_) {
+  return stringifyObservationResult(arguments_);
+}
+function getLatestThought(thoughts) {
+  return thoughts[thoughts.length - 1]?.content ?? "";
+}
+function debugIfVerbose(logger4, verbose, message, data) {
+  if (verbose) {
+    logger4.debug(message, data);
   }
-  return errorMessage;
 }
 
-// src/react/nodes.ts
-var reasoningLogger = createPatternLogger("agentforge:patterns:react:reasoning");
-var actionLogger = createPatternLogger("agentforge:patterns:react:action");
-var observationLogger = createPatternLogger("agentforge:patterns:react:observation");
+// src/react/nodes/reasoning.ts
 function createReasoningNode(llm, tools, systemPrompt, maxIterations, verbose = false) {
   const langchainTools = toLangChainTools(tools);
   const llmWithTools = llm.bindTools ? llm.bindTools(langchainTools) : llm;
   return async (state) => {
     const currentIteration = state.iteration || 0;
     const startTime = Date.now();
-    reasoningLogger.debug("Reasoning iteration started", {
+    debugIfVerbose(reasoningLogger, verbose, "Reasoning iteration started", {
       iteration: currentIteration + 1,
       maxIterations,
-      observationCount: state.observations?.length || 0,
-      hasActions: !!state.actions?.length
+      observationCount: state.observations.length,
+      hasActions: state.actions.length > 0
     });
-    const stateMessages = state.messages || [];
-    const messages = [
-      new SystemMessage(systemPrompt),
-      ...stateMessages.map((msg) => {
-        if (msg.role === "user") return new HumanMessage(msg.content);
-        if (msg.role === "assistant") return new AIMessage(msg.content);
-        if (msg.role === "system") return new SystemMessage(msg.content);
-        if (msg.role === "tool") {
-          return new ToolMessage({
-            content: msg.content,
-            tool_call_id: msg.tool_call_id,
-            name: msg.name
-          });
-        }
-        return new HumanMessage(msg.content);
-      })
-    ];
-    const scratchpad = state.scratchpad || [];
-    if (scratchpad.length > 0) {
-      const scratchpadText = formatScratchpad(scratchpad);
-      messages.push(new SystemMessage(`Previous steps:
-${scratchpadText}`));
-    }
+    const messages = buildReasoningMessages(systemPrompt, state.messages, state.scratchpad);
     const response = await llmWithTools.invoke(messages);
     const thought = typeof response.content === "string" ? response.content : "";
-    const toolCalls = [];
-    if (response.tool_calls && response.tool_calls.length > 0) {
-      for (const toolCall of response.tool_calls) {
-        toolCalls.push({
-          id: toolCall.id || `call_${Date.now()}_${Math.random()}`,
-          name: toolCall.name,
-          arguments: toolCall.args || {},
-          timestamp: Date.now()
-        });
-      }
-    }
+    const toolCalls = extractToolCalls(response);
     const shouldContinue = toolCalls.length > 0 && currentIteration + 1 < maxIterations;
     reasoningLogger.info("Reasoning complete", {
       iteration: currentIteration + 1,
@@ -302,21 +347,49 @@ ${scratchpadText}`));
       thoughts: thought ? [{ content: thought, timestamp: Date.now() }] : [],
       actions: toolCalls,
       iteration: 1,
-      // Add 1 to iteration counter (uses additive reducer)
       shouldContinue,
       response: toolCalls.length === 0 ? thought : void 0
-      // Final response if no tool calls
     };
   };
 }
+
+// src/shared/error-handling.ts
+function isGraphInterrupt(error) {
+  return error !== null && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt";
+}
+function handleNodeError(error, context, verbose = false) {
+  if (isGraphInterrupt(error)) {
+    throw error;
+  }
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (verbose) {
+    console.error(`[${context}] Error:`, errorMessage);
+    if (error instanceof Error && error.stack) {
+      console.error(`[${context}] Stack:`, error.stack);
+    }
+  }
+  return errorMessage;
+}
+
+// src/react/nodes/action.ts
 function createActionNode(tools, verbose = false, enableDeduplication = true) {
   const toolMap = new Map(tools.map((tool) => [tool.metadata.name, tool]));
+  function buildCacheKey(toolName, args) {
+    try {
+      return generateToolCallCacheKey(toolName, args);
+    } catch {
+      debugIfVerbose(actionLogger, verbose, "Skipping deduplication for unserializable tool call", {
+        toolName
+      });
+      return void 0;
+    }
+  }
   return async (state) => {
-    const actions = state.actions || [];
-    const allObservations = state.observations || [];
+    const actions = state.actions;
+    const allObservations = state.observations;
     const iteration = state.iteration || 0;
     const startTime = Date.now();
-    actionLogger.debug("Action node started", {
+    debugIfVerbose(actionLogger, verbose, "Action node started", {
       actionCount: actions.length,
       iteration,
       cacheEnabled: enableDeduplication
@@ -324,18 +397,27 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
     const recentActions = actions.slice(-10);
     const observations = [];
     const executionCache = /* @__PURE__ */ new Map();
+    const actionsById = new Map(actions.map((action) => [action.id, action]));
+    const observedToolCallIds = new Set(
+      allObservations.map((observation) => observation.toolCallId)
+    );
     let cacheSize = 0;
     if (enableDeduplication) {
       for (const observation of allObservations) {
-        const correspondingAction = actions.find((a) => a.id === observation.toolCallId);
+        const correspondingAction = actionsById.get(observation.toolCallId);
         if (correspondingAction) {
-          const cacheKey = generateToolCallCacheKey(correspondingAction.name, correspondingAction.arguments);
-          executionCache.set(cacheKey, observation);
-          cacheSize++;
+          const cacheKey = buildCacheKey(
+            correspondingAction.name,
+            correspondingAction.arguments
+          );
+          if (cacheKey) {
+            executionCache.set(cacheKey, observation);
+            cacheSize++;
+          }
         }
       }
       if (cacheSize > 0) {
-        actionLogger.debug("Deduplication cache built", {
+        debugIfVerbose(actionLogger, verbose, "Deduplication cache built", {
           cacheSize,
           totalObservations: allObservations.length
         });
@@ -344,9 +426,8 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
     let duplicatesSkipped = 0;
     let toolsExecuted = 0;
     for (const action of recentActions) {
-      const existingObservation = allObservations.find((obs) => obs.toolCallId === action.id);
-      if (existingObservation) {
-        actionLogger.debug("Skipping already-processed action", {
+      if (observedToolCallIds.has(action.id)) {
+        debugIfVerbose(actionLogger, verbose, "Skipping already-processed action", {
           toolName: action.name,
           toolCallId: action.id,
           iteration
@@ -354,13 +435,13 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
         continue;
       }
       if (enableDeduplication) {
-        const cacheKey = generateToolCallCacheKey(action.name, action.arguments);
-        const cachedResult = executionCache.get(cacheKey);
+        const cacheKey = buildCacheKey(action.name, action.arguments);
+        const cachedResult = cacheKey ? executionCache.get(cacheKey) : void 0;
         if (cachedResult) {
           duplicatesSkipped++;
           actionLogger.info("Duplicate tool call prevented", {
             toolName: action.name,
-            arguments: action.arguments,
+            argumentKeys: Object.keys(action.arguments),
             iteration,
             cacheHit: true
           });
@@ -385,11 +466,11 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
         continue;
       }
       try {
-        const startTime2 = Date.now();
+        const toolStartTime = Date.now();
         const result = await tool.invoke(action.arguments);
-        const executionTime = Date.now() - startTime2;
+        const executionTime = Date.now() - toolStartTime;
         toolsExecuted++;
-        actionLogger.debug("Tool executed successfully", {
+        debugIfVerbose(actionLogger, verbose, "Tool executed successfully", {
           toolName: action.name,
           executionTime,
           iteration
@@ -401,11 +482,13 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
         };
         observations.push(observation);
         if (enableDeduplication) {
-          const cacheKey = generateToolCallCacheKey(action.name, action.arguments);
-          executionCache.set(cacheKey, observation);
+          const cacheKey = buildCacheKey(action.name, action.arguments);
+          if (cacheKey) {
+            executionCache.set(cacheKey, observation);
+          }
         }
       } catch (error) {
-        const errorMessage = handleNodeError(error, `action:${action.name}`, false);
+        const errorMessage = handleNodeError(error, `action:${action.name}`, verbose);
         actionLogger.error("Tool execution failed", {
           toolName: action.name,
           error: errorMessage,
@@ -420,7 +503,11 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
       }
     }
     if (duplicatesSkipped > 0 || toolsExecuted > 0) {
-      const metrics = buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, observations.length);
+      const metrics = buildDeduplicationMetrics(
+        toolsExecuted,
+        duplicatesSkipped,
+        observations.length
+      );
       actionLogger.info("Action node complete", {
         iteration,
         ...metrics,
@@ -432,41 +519,37 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
     };
   };
 }
+
+// src/react/nodes/observation.ts
 function createObservationNode(verbose = false, returnIntermediateSteps = false) {
   return async (state) => {
-    const observations = state.observations || [];
-    const thoughts = state.thoughts || [];
-    const actions = state.actions || [];
+    const observations = state.observations;
+    const thoughts = state.thoughts;
+    const actions = state.actions;
     const iteration = state.iteration || 0;
-    observationLogger.debug("Processing observations", {
+    debugIfVerbose(observationLogger, verbose, "Processing observations", {
       observationCount: observations.length,
       iteration
     });
     const recentObservations = observations.slice(-10);
     const latestActions = actions.slice(-10);
-    const observationMessages = recentObservations.map((obs) => {
-      const content = obs.error ? `Error: ${obs.error}` : typeof obs.result === "string" ? obs.result : JSON.stringify(obs.result, null, 2);
-      return {
-        role: "tool",
-        content,
-        name: latestActions.find((a) => a.id === obs.toolCallId)?.name,
-        tool_call_id: obs.toolCallId
-        // Include tool_call_id for proper ToolMessage construction
-      };
-    });
-    const scratchpadEntries = returnIntermediateSteps ? [{
-      step: state.iteration,
-      thought: thoughts[thoughts.length - 1]?.content || "",
-      action: latestActions.map((a) => `${a.name}(${JSON.stringify(a.arguments)})`).join(", "),
-      observation: recentObservations.map((obs) => {
-        if (obs.error) {
-          return `Error: ${obs.error}`;
-        }
-        return typeof obs.result === "string" ? obs.result : JSON.stringify(obs.result);
-      }).join("; "),
-      timestamp: Date.now()
-    }] : [];
-    observationLogger.debug("Observation node complete", {
+    const actionNamesById = new Map(latestActions.map((action) => [action.id, action.name]));
+    const observationMessages = recentObservations.map((observation) => ({
+      role: "tool",
+      content: formatObservationContent(observation),
+      name: actionNamesById.get(observation.toolCallId),
+      tool_call_id: observation.toolCallId
+    }));
+    const scratchpadEntries = returnIntermediateSteps ? [
+      {
+        step: iteration,
+        thought: getLatestThought(thoughts),
+        action: formatActionSummary(latestActions),
+        observation: formatObservationSummary(recentObservations),
+        timestamp: Date.now()
+      }
+    ] : [];
+    debugIfVerbose(observationLogger, verbose, "Observation node complete", {
       iteration,
       scratchpadUpdated: returnIntermediateSteps,
       messageCount: observationMessages.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/patterns",
-  "version": "0.15.9",
+  "version": "0.15.11",
   "description": "Production-ready agent workflow patterns for TypeScript including ReAct and Planner-Executor, built on LangGraph.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,13 +41,13 @@
     "url": "https://github.com/TVScoundrel/agentforge/issues"
   },
   "dependencies": {
-    "@agentforge/core": "0.15.9",
+    "@agentforge/core": "0.15.11",
     "@langchain/core": "^1.1.17",
     "@langchain/langgraph": "^1.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@agentforge/testing": "0.15.9",
+    "@agentforge/testing": "0.15.11",
     "@eslint/js": "^9.17.0",
     "@types/node": "^22.10.2",
     "eslint": "^9.17.0",