feat: Refactor sampling and workflow executors for improved clarity and maintainability; enhance argument handling and logging

Author: yaonyan

packages/core/src/executors/sampling/agentic-sampling-executor.ts

@@ -18,23 +18,23 @@ export class SamplingExecutor extends BaseSamplingExecutor {
     allToolNames: string[],
     toolNameToDetailList: [string, ExternalTool][],
     server: ComposableMCPServer,
-    config?: SamplingConfig,
+    config?: SamplingConfig
   ) {
     super(
       name,
       description,
       allToolNames,
       toolNameToDetailList,
       server,
-      config,
+      config
     );
 
     // Create AgenticExecutor for tool execution
     this.agenticExecutor = new AgenticExecutor(
       name,
       allToolNames,
       toolNameToDetailList as [string, unknown][],
-      server,
+      server
     );
   }
 
@@ -65,7 +65,7 @@ export class SamplingExecutor extends BaseSamplingExecutor {
 
   executeSampling(
     args: Record<string, unknown>,
-    schema: Record<string, unknown>,
+    schema: Record<string, unknown>
   ) {
     const validationResult = this.validateSchema(args, schema);
     if (!validationResult.valid) {
@@ -85,30 +85,30 @@ export class SamplingExecutor extends BaseSamplingExecutor {
     const createArgsDef = createArgsDefFactory(
       this.name,
       this.allToolNames,
-      this.buildDepGroups(),
+      this.buildDepGroups()
     );
 
     const agenticSchema = createArgsDef.forAgentic(
       this.toolNameToDetailList as [string, unknown][],
-      true,
+      true
     );
 
     const systemPrompt = this.buildSystemPrompt(
       args.userRequest as string,
-      agenticSchema,
+      agenticSchema
     );
-    return this.runSamplingLoop(systemPrompt, agenticSchema);
+    return this.runSamplingLoop(() => systemPrompt, agenticSchema);
   }
 
   protected async processAction(
     parsedData: Record<string, unknown>,
-    schema: Record<string, unknown>,
+    schema: Record<string, unknown>
   ): Promise<CallToolResult> {
     // Define the expected tool call data structure
     const toolCallData = parsedData;
 
     if (toolCallData.action === "complete") {
-      const reasoning = toolCallData.reasoning as string || "Task completed";
+      const reasoning = (toolCallData.reasoning as string) || "Task completed";
       return this.createCompletionResult(reasoning);
     }
 
@@ -118,25 +118,24 @@ export class SamplingExecutor extends BaseSamplingExecutor {
 
       const toolResult = await this.agenticExecutor.execute(
         toolCallData,
-        schema,
+        schema
       );
 
       // Extract result text
-      const resultText = toolResult.content
-        ?.filter((content) => content.type === "text")
-        ?.map((content) => content.text)
-        ?.join("\n") || "No result";
+      const resultText =
+        toolResult.content
+          ?.filter((content) => content.type === "text")
+          ?.map((content) => content.text)
+          ?.join("\n") || "No result";
 
       // Add conversation history updates
-      this.conversationHistory.push(
-        {
-          role: "assistant",
-          content: {
-            type: "text",
-            text: resultText,
-          },
+      this.conversationHistory.push({
+        role: "assistant",
+        content: {
+          type: "text",
+          text: resultText,
         },
-      );
+      });
 
       return toolResult;
     } catch (error) {
@@ -147,21 +146,23 @@ export class SamplingExecutor extends BaseSamplingExecutor {
 
   private buildSystemPrompt(
     userRequest: string,
-    agenticSchema: Record<string, unknown>,
+    agenticSchema: Record<string, unknown>
   ): string {
-    const toolList = this.allToolNames.map((name) => {
-      const tool = this.toolNameToDetailList.find(([toolName]) =>
-        toolName === name
-      );
-      const toolSchema = this.server.getInternalToolSchema(name);
-
-      if (tool && tool[1]) {
-        return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
-      } else if (toolSchema) {
-        return `- ${name}: ${toolSchema.description}`;
-      }
-      return `- ${name}`;
-    }).join("\n");
+    const toolList = this.allToolNames
+      .map((name) => {
+        const tool = this.toolNameToDetailList.find(
+          ([toolName]) => toolName === name
+        );
+        const toolSchema = this.server.getInternalToolSchema(name);
+
+        if (tool && tool[1]) {
+          return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
+        } else if (toolSchema) {
+          return `- ${name}: ${toolSchema.description}`;
+        }
+        return `- ${name}`;
+      })
+      .join("\n");
 
     // Build the complete schema using forAgentic
 

packages/core/src/executors/sampling/base-sampling-executor.ts

@@ -75,10 +75,10 @@ export abstract class BaseSamplingExecutor {
         const response = await this.server.createMessage({
           systemPrompt: systemPrompt(),
           messages: this.conversationHistory,
-          maxTokens: 9999,
+          maxTokens: Number.MAX_SAFE_INTEGER,
         });
 
-        const responseContent = response.content.text as string || "{}";
+        const responseContent = (response.content.text as string) || "{}";
 
         // Parse JSON response
         let parsedData: Record<string, unknown>;
@@ -90,13 +90,30 @@ export abstract class BaseSamplingExecutor {
           continue;
         }
 
+        if (parsedData) {
+          this.conversationHistory.push({
+            role: "assistant",
+            content: {
+              type: "text",
+              text: `Executing with arguments: ${
+                JSON.stringify(
+                  parsedData,
+                  null,
+                  2,
+                )
+              }`,
+            },
+          });
+        }
+
         // Process the parsed data using subclass implementation
         const result = await this.processAction(parsedData, schema, state);
+        this.logIterationProgress(parsedData, result);
 
         if (result.isError) {
           // If processing resulted in an error, add to conversation history
           this.conversationHistory.push({
-            role: "assistant",
+            role: "user",
             content: {
               type: "text",
               text: result.content[0].text as string,
@@ -108,13 +125,6 @@ export abstract class BaseSamplingExecutor {
         if (result.isComplete) {
           return result;
         }
-
-        // Add result to conversation history if not complete
-        if (result.conversationUpdate) {
-          this.conversationHistory.push(
-            ...result.conversationUpdate as ConversationMessage[],
-          );
-        }
       }
 
       // Reached maximum iterations
@@ -208,58 +218,40 @@ ${text}
 
     let details = "\n\n**Detailed Conversation History:**";
 
-    this.conversationHistory.forEach((message, index) => {
-      details += `\n\n**Message ${index + 1} (${message.role}):**\n`;
-
+    this.conversationHistory.forEach((message) => {
       if (message.role === "assistant") {
         // Try to parse JSON and format nicely
         try {
           const parsed = JSON.parse(message.content.text);
-          details += "```json\n" + JSON.stringify(parsed, null, 2) + "\n```";
+          details += "\n```json\n" + JSON.stringify(parsed, null, 2) + "\n```";
         } catch {
           // Not JSON, show as text
-          details += "```\n" + message.content.text + "\n```";
+          details += "\n```\n" + message.content.text + "\n```";
         }
       } else {
         // User message
-        details += "```\n" + message.content.text + "\n```";
+        details += "\n```\n" + message.content.text + "\n```";
       }
     });
 
-    // Add summary
-    const toolsUsed = new Set<string>();
-    let errorCount = 0;
-
-    for (const message of this.conversationHistory) {
-      if (message.role === "assistant") {
-        try {
-          const parsed = JSON.parse(message.content.text);
-          if (parsed.action && parsed.action !== "complete") {
-            toolsUsed.add(parsed.action);
-          }
-        } catch {
-          if (
-            message.content.text.includes("JSON parsing failed") ||
-            message.content.text.toLowerCase().includes("error")
-          ) {
-            errorCount++;
-          }
-        }
-      }
-    }
-
-    details += "\n\n**Summary:**";
-    details += `\n- Total messages: ${this.conversationHistory.length}`;
-    if (toolsUsed.size > 0) {
-      details += `\n- Tools used: ${Array.from(toolsUsed).join(", ")}`;
-    }
-    if (errorCount > 0) {
-      details += `\n- Errors encountered: ${errorCount}`;
-    }
-
     return details;
   }
 
+  protected logIterationProgress(
+    parsedData: Record<string, unknown>,
+    result: CallToolResult,
+  ): void {
+    // Optional: Log iteration progress for debugging
+    console.log(
+      `Iteration ${this.currentIteration + 1}/${this.maxIterations}:`,
+      {
+        parsedData,
+        isError: result.isError,
+        isComplete: result.isComplete,
+      },
+    );
+  }
+
   // Abstract methods that subclasses must implement
   protected abstract processAction<TState>(
     parsedData: Record<string, unknown>,