@agentforge/patterns 0.16.88 → 0.16.90

package/dist/index.cjs

@@ -1140,32 +1140,17 @@ var plannerLogger = createPatternLogger("agentforge:patterns:plan-execute:planne
 var executorLogger = createPatternLogger("agentforge:patterns:plan-execute:executor");
 var replannerLogger = createPatternLogger("agentforge:patterns:plan-execute:replanner");
 
-// src/plan-execute/serialization.ts
+// src/plan-execute/model-response.ts
 function hasTextContentPart(value) {
   return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
 }
-function stringifyWithFallback(value, fallbackLabel) {
+function stringifyModelContent(value) {
   try {
     const serialized = JSON.stringify(value);
-    if (serialized === void 0) {
-      return "undefined";
-    }
-    return serialized;
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    return `[${fallbackLabel}: ${reason}]`;
-  }
-}
-function toJsonSafeValue(value) {
-  try {
-    const serialized = JSON.stringify(value);
-    if (serialized === void 0) {
-      return void 0;
-    }
-    return JSON.parse(serialized);
+    return serialized === void 0 ? "undefined" : serialized;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    return `[Unserializable step result: ${reason}]`;
+    return `[Unserializable model content: ${reason}]`;
   }
 }
 function normalizeModelContent(content) {
@@ -1183,10 +1168,15 @@ function normalizeModelContent(content) {
       return textParts.join("\n");
     }
   }
-  return stringifyWithFallback(content, "Unserializable model content");
+  return stringifyModelContent(content);
 }
-function serializePlanExecuteResult(result) {
-  return stringifyWithFallback(result, "Unserializable step result");
+function parseModelResponse(content, context) {
+  const normalized = normalizeModelContent(content);
+  try {
+    return JSON.parse(normalized);
+  } catch (parseError) {
+    throw new Error(`Failed to parse ${context} from LLM response: ${parseError}`);
+  }
 }
 
 // src/plan-execute/planner-node.ts
@@ -1215,19 +1205,13 @@ function createPlannerNode(config) {
         new import_messages2.HumanMessage(userPrompt)
       ];
       const response = await model.invoke(messages);
-      const content = normalizeModelContent(response.content);
-      let plan;
-      try {
-        const parsed = JSON.parse(content);
-        plan = {
-          steps: parsed.steps.slice(0, maxSteps),
-          goal: parsed.goal || state.input || "",
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          confidence: parsed.confidence
-        };
-      } catch (parseError) {
-        throw new Error(`Failed to parse plan from LLM response: ${parseError}`);
-      }
+      const parsed = parseModelResponse(response.content, "plan");
+      const plan = {
+        steps: parsed.steps.slice(0, maxSteps),
+        goal: parsed.goal || state.input || "",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        confidence: parsed.confidence
+      };
       plannerLogger.info("Plan created", {
         stepCount: plan.steps.length,
         goal: plan.goal.substring(0, 100),
@@ -1418,6 +1402,37 @@ function createExecutorNode(config) {
 
 // src/plan-execute/replanner-node.ts
 var import_messages3 = require("@langchain/core/messages");
+
+// src/plan-execute/serialization.ts
+function stringifyWithFallback(value, fallbackLabel) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return "undefined";
+    }
+    return serialized;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return `[${fallbackLabel}: ${reason}]`;
+  }
+}
+function toJsonSafeValue(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return void 0;
+    }
+    return JSON.parse(serialized);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return `[Unserializable step result: ${reason}]`;
+  }
+}
+function serializePlanExecuteResult(result) {
+  return stringifyWithFallback(result, "Unserializable step result");
+}
+
+// src/plan-execute/replanner-node.ts
 function createReplannerNode(config) {
   const {
     model,
@@ -1455,13 +1470,7 @@ function createReplannerNode(config) {
         new import_messages3.HumanMessage(userPrompt)
       ];
       const response = await model.invoke(messages);
-      const content = normalizeModelContent(response.content);
-      let decision;
-      try {
-        decision = JSON.parse(content);
-      } catch (parseError) {
-        throw new Error(`Failed to parse replan decision from LLM response: ${parseError}`);
-      }
+      const decision = parseModelResponse(response.content, "replan decision");
       if (decision.shouldReplan) {
         replannerLogger.info("Replanning triggered", {
           reason: decision.reason,

package/dist/index.d.cts

@@ -2973,249 +2973,68 @@ type MultiAgentStateType = {
     error?: string;
 };
 
-/**
- * Type Definitions for Multi-Agent Coordination Pattern
- *
- * This module defines TypeScript types for the Multi-Agent pattern.
- *
- * @module patterns/multi-agent/types
- */
-
-type WorkerTool = Tool<never, unknown>;
-/**
- * Runtime config passed to worker execution functions.
- *
- * Includes LangGraph's RunnableConfig while remaining open to caller-defined
- * keys used by integrations.
- */
-type WorkerExecutionConfig = RunnableConfig | Record<string, unknown>;
-/**
- * Configuration for the supervisor node
- */
 interface SupervisorConfig {
-    /**
-     * Language model for routing decisions (used for LLM-based routing)
-     */
     model?: BaseChatModel;
-    /**
-     * Routing strategy to use
-     */
     strategy: RoutingStrategy;
-    /**
-     * System prompt for the supervisor (LLM-based routing only)
-     */
     systemPrompt?: string;
-    /**
-     * Custom routing function (for rule-based routing)
-     */
     routingFn?: (state: MultiAgentStateType) => Promise<RoutingDecision>;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
-    /**
-     * Maximum number of routing iterations
-     */
     maxIterations?: number;
     /**
-     * Maximum number of tool call retries before requiring routing decision
-     *
-     * Prevents infinite loops where the supervisor keeps calling tools without making a routing decision.
-     *
+     * Maximum number of tool call retries before requiring a routing decision.
+     * Prevents infinite loops where the supervisor keeps calling tools without
+     * making a routing decision.
      * @default 3
      */
     maxToolRetries?: number;
 }
-/**
- * Configuration for a worker agent node
- */
+
+type WorkerExecutionConfig = RunnableConfig | Record<string, unknown>;
+type WorkerTool = Tool<never, unknown>;
 interface WorkerConfig {
-    /**
-     * Unique identifier for this worker
-     */
     id: string;
-    /**
-     * Worker capabilities
-     */
     capabilities: WorkerCapabilities;
-    /**
-     * Language model for the worker
-     */
     model?: BaseChatModel;
-    /**
-     * Available tools for this worker
-     */
     tools?: WorkerTool[];
-    /**
-     * System prompt for the worker
-     */
     systemPrompt?: string;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
     /**
-     * Custom execution function
-     *
-     * If provided, this function will be used to execute tasks for this worker.
-     * Takes precedence over the `agent` property.
-     *
-     * The config parameter contains LangGraph runtime configuration including
-     * thread_id for checkpointing, which is required for interrupt functionality.
+     * Custom execution function. When provided, this takes precedence over
+     * the `agent` property.
      */
     executeFn?: (state: MultiAgentStateType, config?: WorkerExecutionConfig) => Promise<Partial<MultiAgentStateType>>;
     /**
-     * ReAct agent instance
-     *
-     * If provided, the Multi-Agent pattern will automatically wrap this ReAct agent
-     * to work as a worker. The agent should be a compiled LangGraph StateGraph
-     * (e.g., created with `createReActAgent()`).
-     *
-     * Note: `executeFn` takes precedence over `agent` if both are provided.
-     *
-     * @example
-     * ```typescript
-     * const hrAgent = createReActAgent({ model, tools, systemPrompt });
-     *
-     * const system = createMultiAgentSystem({
-     *   workers: [{
-     *     id: 'hr',
-     *     capabilities: { skills: ['hr'], ... },
-     *     agent: hrAgent,  // Automatically wrapped!
-     *   }]
-     * });
-     * ```
+     * ReAct agent instance. `executeFn` takes precedence when both are set.
      */
     agent?: CompiledStateGraph<unknown, unknown>;
 }
-/**
- * Configuration for the aggregator node
- */
+
 interface AggregatorConfig {
-    /**
-     * Language model for aggregation (optional)
-     */
     model?: BaseChatModel;
-    /**
-     * System prompt for aggregation
-     */
     systemPrompt?: string;
-    /**
-     * Custom aggregation function
-     */
     aggregateFn?: (state: MultiAgentStateType) => Promise<string>;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
 }
-/**
- * Configuration for the multi-agent system
- */
 interface MultiAgentSystemConfig {
-    /**
-     * Supervisor configuration
-     */
     supervisor: SupervisorConfig;
-    /**
-     * Worker configurations
-     */
     workers: WorkerConfig[];
-    /**
-     * Aggregator configuration (optional)
-     */
     aggregator?: AggregatorConfig;
-    /**
-     * Maximum iterations for the entire system
-     */
     maxIterations?: number;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
     /**
-     * Optional checkpointer for state persistence
-     * Required for human-in-the-loop workflows (askHuman tool), interrupts, and conversation continuity
-     *
-     * **Worker Checkpoint Namespaces:**
-     * When worker agents are configured with `checkpointer: true`, they automatically use
-     * separate checkpoint namespaces to enable proper handling of nested graph interrupts.
-     *
-     * The namespace format is: `{parent_thread_id}:worker:{workerId}`
-     *
-     * For example, if the parent thread ID is `thread_abc123` and the worker ID is `hr`,
-     * the worker's checkpoint namespace will be `thread_abc123:worker:hr`.
-     *
-     * This allows worker agents to use the `askHuman` tool without causing infinite loops,
-     * as each worker's state is saved and resumed independently.
-     *
-     * @example
-     * Basic usage with checkpointer:
-     * ```typescript
-     * import { MemorySaver } from '@langchain/langgraph';
-     *
-     * const checkpointer = new MemorySaver();
-     * const system = createMultiAgentSystem({
-     *   supervisor: { strategy: 'skill-based', model },
-     *   workers: [...],
-     *   checkpointer
-     * });
-     * ```
-     *
-     * @example
-     * Worker agents with nested graph interrupts:
-     * ```typescript
-     * import { MemorySaver } from '@langchain/langgraph';
-     * import { createReActAgent } from '@agentforge/patterns';
-     * import { createAskHumanTool } from '@agentforge/tools';
-     *
-     * // Create worker agent with checkpointer: true
-     * const hrAgent = createReActAgent({
-     *   model,
-     *   tools: [createAskHumanTool(), ...hrTools],
-     *   checkpointer: true  // Use parent's checkpointer with separate namespace
-     * });
-     *
-     * // Create multi-agent system with checkpointer
-     * const system = createMultiAgentSystem({
-     *   supervisor: { strategy: 'skill-based', model },
-     *   workers: [{
-     *     id: 'hr',
-     *     capabilities: { skills: ['hr'], ... },
-     *     agent: hrAgent
-     *   }],
-     *   checkpointer: new MemorySaver()
-     * });
-     *
-     * // When hrAgent calls askHuman, it will use checkpoint namespace:
-     * // thread_abc123:worker:hr
-     * ```
+     * Optional checkpointer for state persistence and human-in-the-loop flows.
+     * Worker agents use isolated namespaces in the form
+     * `{parent_thread_id}:worker:{workerId}` so nested interrupts can resume
+     * without looping through the parent graph.
      */
     checkpointer?: BaseCheckpointSaver;
 }
-/**
- * Node type for multi-agent graph
- */
+
 type MultiAgentNode = 'supervisor' | 'aggregator' | string;
-/**
- * Route type for multi-agent graph
- */
 type MultiAgentRoute = 'continue' | 'aggregate' | 'end' | string | string[];
-/**
- * Router function type
- */
 type MultiAgentRouter = (state: MultiAgentStateType) => MultiAgentRoute;
-/**
- * Routing strategy implementation
- */
 interface RoutingStrategyImpl {
-    /**
-     * Name of the strategy
-     */
     name: RoutingStrategy;
-    /**
-     * Execute the routing strategy
-     */
     route: (state: MultiAgentStateType, config: SupervisorConfig) => Promise<RoutingDecision>;
 }
 

package/dist/index.d.ts

@@ -2973,249 +2973,68 @@ type MultiAgentStateType = {
     error?: string;
 };
 
-/**
- * Type Definitions for Multi-Agent Coordination Pattern
- *
- * This module defines TypeScript types for the Multi-Agent pattern.
- *
- * @module patterns/multi-agent/types
- */
-
-type WorkerTool = Tool<never, unknown>;
-/**
- * Runtime config passed to worker execution functions.
- *
- * Includes LangGraph's RunnableConfig while remaining open to caller-defined
- * keys used by integrations.
- */
-type WorkerExecutionConfig = RunnableConfig | Record<string, unknown>;
-/**
- * Configuration for the supervisor node
- */
 interface SupervisorConfig {
-    /**
-     * Language model for routing decisions (used for LLM-based routing)
-     */
     model?: BaseChatModel;
-    /**
-     * Routing strategy to use
-     */
     strategy: RoutingStrategy;
-    /**
-     * System prompt for the supervisor (LLM-based routing only)
-     */
     systemPrompt?: string;
-    /**
-     * Custom routing function (for rule-based routing)
-     */
     routingFn?: (state: MultiAgentStateType) => Promise<RoutingDecision>;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
-    /**
-     * Maximum number of routing iterations
-     */
     maxIterations?: number;
     /**
-     * Maximum number of tool call retries before requiring routing decision
-     *
-     * Prevents infinite loops where the supervisor keeps calling tools without making a routing decision.
-     *
+     * Maximum number of tool call retries before requiring a routing decision.
+     * Prevents infinite loops where the supervisor keeps calling tools without
+     * making a routing decision.
      * @default 3
      */
     maxToolRetries?: number;
 }
-/**
- * Configuration for a worker agent node
- */
+
+type WorkerExecutionConfig = RunnableConfig | Record<string, unknown>;
+type WorkerTool = Tool<never, unknown>;
 interface WorkerConfig {
-    /**
-     * Unique identifier for this worker
-     */
     id: string;
-    /**
-     * Worker capabilities
-     */
     capabilities: WorkerCapabilities;
-    /**
-     * Language model for the worker
-     */
     model?: BaseChatModel;
-    /**
-     * Available tools for this worker
-     */
     tools?: WorkerTool[];
-    /**
-     * System prompt for the worker
-     */
     systemPrompt?: string;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
     /**
-     * Custom execution function
-     *
-     * If provided, this function will be used to execute tasks for this worker.
-     * Takes precedence over the `agent` property.
-     *
-     * The config parameter contains LangGraph runtime configuration including
-     * thread_id for checkpointing, which is required for interrupt functionality.
+     * Custom execution function. When provided, this takes precedence over
+     * the `agent` property.
      */
     executeFn?: (state: MultiAgentStateType, config?: WorkerExecutionConfig) => Promise<Partial<MultiAgentStateType>>;
     /**
-     * ReAct agent instance
-     *
-     * If provided, the Multi-Agent pattern will automatically wrap this ReAct agent
-     * to work as a worker. The agent should be a compiled LangGraph StateGraph
-     * (e.g., created with `createReActAgent()`).
-     *
-     * Note: `executeFn` takes precedence over `agent` if both are provided.
-     *
-     * @example
-     * ```typescript
-     * const hrAgent = createReActAgent({ model, tools, systemPrompt });
-     *
-     * const system = createMultiAgentSystem({
-     *   workers: [{
-     *     id: 'hr',
-     *     capabilities: { skills: ['hr'], ... },
-     *     agent: hrAgent,  // Automatically wrapped!
-     *   }]
-     * });
-     * ```
+     * ReAct agent instance. `executeFn` takes precedence when both are set.
      */
     agent?: CompiledStateGraph<unknown, unknown>;
 }
-/**
- * Configuration for the aggregator node
- */
+
 interface AggregatorConfig {
-    /**
-     * Language model for aggregation (optional)
-     */
     model?: BaseChatModel;
-    /**
-     * System prompt for aggregation
-     */
     systemPrompt?: string;
-    /**
-     * Custom aggregation function
-     */
     aggregateFn?: (state: MultiAgentStateType) => Promise<string>;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
 }
-/**
- * Configuration for the multi-agent system
- */
 interface MultiAgentSystemConfig {
-    /**
-     * Supervisor configuration
-     */
     supervisor: SupervisorConfig;
-    /**
-     * Worker configurations
-     */
     workers: WorkerConfig[];
-    /**
-     * Aggregator configuration (optional)
-     */
     aggregator?: AggregatorConfig;
-    /**
-     * Maximum iterations for the entire system
-     */
     maxIterations?: number;
-    /**
-     * Whether to include verbose logging
-     */
     verbose?: boolean;
     /**
-     * Optional checkpointer for state persistence
-     * Required for human-in-the-loop workflows (askHuman tool), interrupts, and conversation continuity
-     *
-     * **Worker Checkpoint Namespaces:**
-     * When worker agents are configured with `checkpointer: true`, they automatically use
-     * separate checkpoint namespaces to enable proper handling of nested graph interrupts.
-     *
-     * The namespace format is: `{parent_thread_id}:worker:{workerId}`
-     *
-     * For example, if the parent thread ID is `thread_abc123` and the worker ID is `hr`,
-     * the worker's checkpoint namespace will be `thread_abc123:worker:hr`.
-     *
-     * This allows worker agents to use the `askHuman` tool without causing infinite loops,
-     * as each worker's state is saved and resumed independently.
-     *
-     * @example
-     * Basic usage with checkpointer:
-     * ```typescript
-     * import { MemorySaver } from '@langchain/langgraph';
-     *
-     * const checkpointer = new MemorySaver();
-     * const system = createMultiAgentSystem({
-     *   supervisor: { strategy: 'skill-based', model },
-     *   workers: [...],
-     *   checkpointer
-     * });
-     * ```
-     *
-     * @example
-     * Worker agents with nested graph interrupts:
-     * ```typescript
-     * import { MemorySaver } from '@langchain/langgraph';
-     * import { createReActAgent } from '@agentforge/patterns';
-     * import { createAskHumanTool } from '@agentforge/tools';
-     *
-     * // Create worker agent with checkpointer: true
-     * const hrAgent = createReActAgent({
-     *   model,
-     *   tools: [createAskHumanTool(), ...hrTools],
-     *   checkpointer: true  // Use parent's checkpointer with separate namespace
-     * });
-     *
-     * // Create multi-agent system with checkpointer
-     * const system = createMultiAgentSystem({
-     *   supervisor: { strategy: 'skill-based', model },
-     *   workers: [{
-     *     id: 'hr',
-     *     capabilities: { skills: ['hr'], ... },
-     *     agent: hrAgent
-     *   }],
-     *   checkpointer: new MemorySaver()
-     * });
-     *
-     * // When hrAgent calls askHuman, it will use checkpoint namespace:
-     * // thread_abc123:worker:hr
-     * ```
+     * Optional checkpointer for state persistence and human-in-the-loop flows.
+     * Worker agents use isolated namespaces in the form
+     * `{parent_thread_id}:worker:{workerId}` so nested interrupts can resume
+     * without looping through the parent graph.
      */
     checkpointer?: BaseCheckpointSaver;
 }
-/**
- * Node type for multi-agent graph
- */
+
 type MultiAgentNode = 'supervisor' | 'aggregator' | string;
-/**
- * Route type for multi-agent graph
- */
 type MultiAgentRoute = 'continue' | 'aggregate' | 'end' | string | string[];
-/**
- * Router function type
- */
 type MultiAgentRouter = (state: MultiAgentStateType) => MultiAgentRoute;
-/**
- * Routing strategy implementation
- */
 interface RoutingStrategyImpl {
-    /**
-     * Name of the strategy
-     */
     name: RoutingStrategy;
-    /**
-     * Execute the routing strategy
-     */
     route: (state: MultiAgentStateType, config: SupervisorConfig) => Promise<RoutingDecision>;
 }
 

package/dist/index.js

@@ -1042,32 +1042,17 @@ var plannerLogger = createPatternLogger("agentforge:patterns:plan-execute:planne
 var executorLogger = createPatternLogger("agentforge:patterns:plan-execute:executor");
 var replannerLogger = createPatternLogger("agentforge:patterns:plan-execute:replanner");
 
-// src/plan-execute/serialization.ts
+// src/plan-execute/model-response.ts
 function hasTextContentPart(value) {
   return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
 }
-function stringifyWithFallback(value, fallbackLabel) {
+function stringifyModelContent(value) {
   try {
     const serialized = JSON.stringify(value);
-    if (serialized === void 0) {
-      return "undefined";
-    }
-    return serialized;
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    return `[${fallbackLabel}: ${reason}]`;
-  }
-}
-function toJsonSafeValue(value) {
-  try {
-    const serialized = JSON.stringify(value);
-    if (serialized === void 0) {
-      return void 0;
-    }
-    return JSON.parse(serialized);
+    return serialized === void 0 ? "undefined" : serialized;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    return `[Unserializable step result: ${reason}]`;
+    return `[Unserializable model content: ${reason}]`;
   }
 }
 function normalizeModelContent(content) {
@@ -1085,10 +1070,15 @@ function normalizeModelContent(content) {
       return textParts.join("\n");
     }
   }
-  return stringifyWithFallback(content, "Unserializable model content");
+  return stringifyModelContent(content);
 }
-function serializePlanExecuteResult(result) {
-  return stringifyWithFallback(result, "Unserializable step result");
+function parseModelResponse(content, context) {
+  const normalized = normalizeModelContent(content);
+  try {
+    return JSON.parse(normalized);
+  } catch (parseError) {
+    throw new Error(`Failed to parse ${context} from LLM response: ${parseError}`);
+  }
 }
 
 // src/plan-execute/planner-node.ts
@@ -1117,19 +1107,13 @@ function createPlannerNode(config) {
         new HumanMessage2(userPrompt)
       ];
       const response = await model.invoke(messages);
-      const content = normalizeModelContent(response.content);
-      let plan;
-      try {
-        const parsed = JSON.parse(content);
-        plan = {
-          steps: parsed.steps.slice(0, maxSteps),
-          goal: parsed.goal || state.input || "",
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          confidence: parsed.confidence
-        };
-      } catch (parseError) {
-        throw new Error(`Failed to parse plan from LLM response: ${parseError}`);
-      }
+      const parsed = parseModelResponse(response.content, "plan");
+      const plan = {
+        steps: parsed.steps.slice(0, maxSteps),
+        goal: parsed.goal || state.input || "",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        confidence: parsed.confidence
+      };
       plannerLogger.info("Plan created", {
         stepCount: plan.steps.length,
         goal: plan.goal.substring(0, 100),
@@ -1320,6 +1304,37 @@ function createExecutorNode(config) {
 
 // src/plan-execute/replanner-node.ts
 import { HumanMessage as HumanMessage3, SystemMessage as SystemMessage3 } from "@langchain/core/messages";
+
+// src/plan-execute/serialization.ts
+function stringifyWithFallback(value, fallbackLabel) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return "undefined";
+    }
+    return serialized;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return `[${fallbackLabel}: ${reason}]`;
+  }
+}
+function toJsonSafeValue(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return void 0;
+    }
+    return JSON.parse(serialized);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return `[Unserializable step result: ${reason}]`;
+  }
+}
+function serializePlanExecuteResult(result) {
+  return stringifyWithFallback(result, "Unserializable step result");
+}
+
+// src/plan-execute/replanner-node.ts
 function createReplannerNode(config) {
   const {
     model,
@@ -1357,13 +1372,7 @@ function createReplannerNode(config) {
         new HumanMessage3(userPrompt)
       ];
       const response = await model.invoke(messages);
-      const content = normalizeModelContent(response.content);
-      let decision;
-      try {
-        decision = JSON.parse(content);
-      } catch (parseError) {
-        throw new Error(`Failed to parse replan decision from LLM response: ${parseError}`);
-      }
+      const decision = parseModelResponse(response.content, "replan decision");
       if (decision.shouldReplan) {
         replannerLogger.info("Replanning triggered", {
           reason: decision.reason,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/patterns",
-  "version": "0.16.88",
+  "version": "0.16.90",
   "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.16.88",
+    "@agentforge/core": "0.16.90",
     "@langchain/core": "^1.1.17",
     "@langchain/langgraph": "^1.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@agentforge/testing": "0.16.88",
+    "@agentforge/testing": "0.16.90",
     "@eslint/js": "^9.17.0",
     "@types/node": "^22.10.2",
     "eslint": "^9.17.0",