fix: add debug logging to TS e2e tests

Author: clareliguori

e2e_tests/test_questions.json

@@ -10,5 +10,5 @@
   "Who wrote the book Pride and Prejudice?",
   "How do you pronounce the word 'hello'?",
   "Tell me the inspirational quote of the day.",
-  "Who is Tom Cruise?"
+  "Who is Tom Cruise? (use his Wikipedia article to answer)"
 ]

e2e_tests/typescript/src/chat_session.ts

@@ -17,10 +17,24 @@ export class ChatSession {
       for (const userInput of this.userUtterances) {
         console.log(`\nYou: ${userInput}`);
         process.stdout.write("\nAssistant: ");
-        await this.agent.invoke(userInput);
+
+        logger.info(`Starting agent invocation for: "${userInput}"`);
+        const startTime = Date.now();
+
+        try {
+          await this.agent.invoke(userInput);
+          const duration = Date.now() - startTime;
+          logger.info(`Agent invocation completed in ${duration}ms`);
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          logger.error(`Agent invocation failed after ${duration}ms:`, error);
+          throw error;
+        }
       }
     } finally {
+      logger.info("Disconnecting MCP clients...");
       await Promise.all(this.mcpClients.map(client => client.disconnect()));
+      logger.info("All MCP clients disconnected");
     }
   }
 }

e2e_tests/typescript/src/main.ts

@@ -10,43 +10,76 @@ import {
 import logger from "./logger.js";
 
 async function main(): Promise<void> {
+  logger.info(`Starting e2e test with LOG_LEVEL=${process.env.LOG_LEVEL || 'info'}`);
+  logger.info(`Node version: ${process.version}`);
+
   const config = new Configuration();
   const serverConfig = Configuration.loadConfig("./servers_config.json");
 
   const mcpClients = [];
 
+  logger.info("Initializing MCP clients...");
   for (const [name, srvConfig] of Object.entries(serverConfig.stdioServers || {})) {
-    mcpClients.push(await createStdioClient(name, srvConfig));
+    try {
+      mcpClients.push(await createStdioClient(name, srvConfig));
+    } catch (error) {
+      logger.error(`Failed to initialize stdio server ${name}:`, error);
+      throw error;
+    }
   }
 
   for (const [name, srvConfig] of Object.entries(serverConfig.lambdaFunctionServers || {})) {
-    mcpClients.push(await createLambdaFunctionClient(name, srvConfig));
+    try {
+      mcpClients.push(await createLambdaFunctionClient(name, srvConfig));
+    } catch (error) {
+      logger.error(`Failed to initialize lambda function server ${name}:`, error);
+      throw error;
+    }
   }
 
   for (const [name, srvConfig] of Object.entries(serverConfig.lambdaFunctionUrls || {})) {
-    mcpClients.push(await createLambdaFunctionUrlClient(name, srvConfig));
+    try {
+      mcpClients.push(await createLambdaFunctionUrlClient(name, srvConfig));
+    } catch (error) {
+      logger.error(`Failed to initialize lambda function URL server ${name}:`, error);
+      throw error;
+    }
   }
 
   for (const [name, srvConfig] of Object.entries(serverConfig.oAuthServers || {})) {
-    mcpClients.push(await createAutomatedOAuthClient(name, srvConfig));
+    try {
+      mcpClients.push(await createAutomatedOAuthClient(name, srvConfig));
+    } catch (error) {
+      logger.error(`Failed to initialize OAuth server ${name}:`, error);
+      throw error;
+    }
   }
 
+  logger.info(`Successfully initialized ${mcpClients.length} MCP clients`);
+
   const userUtterances = Configuration.loadConfig("../test_questions.json") as string[];
+  logger.info(`Loaded ${userUtterances.length} test questions`);
 
+  logger.info("Initializing Bedrock model...");
   const model = new BedrockModel({
     region: config.bedrockClient.config.region as string,
     modelId: config.modelId,
   });
+  logger.info(`Using model: ${config.modelId} in region: ${config.bedrockClient.config.region}`);
 
+  logger.info("Creating agent...");
   const agent = new Agent({
     model,
     tools: mcpClients,
     systemPrompt: "You are a helpful assistant.",
   });
+  logger.info("Agent created successfully");
 
   const chatSession = new ChatSession(agent, userUtterances, mcpClients);
 
+  logger.info("Starting chat session...");
   await chatSession.start();
+  logger.info("Chat session completed successfully");
 }
 
 process.on("unhandledRejection", (reason, promise) => {
@@ -56,6 +89,8 @@ process.on("unhandledRejection", (reason, promise) => {
 
 main().catch((error) => {
   logger.error("Error in main:", error);
+  if (error.stack) {
+    logger.error("Stack trace:", error.stack);
+  }
   process.exit(1);
 });
-

e2e_tests/typescript/src/mcp_clients.ts

@@ -18,6 +18,7 @@ import logger from "./logger.js";
 
 export async function createStdioClient(name: string, config: any): Promise<McpClient> {
   logger.info(`Initializing stdio server: ${name}`);
+  logger.debug(`Stdio config: ${JSON.stringify({ command: config.command, args: config.args })}`);
   const transport = new StdioClientTransport({
     command: config.command,
     args: config.args,
@@ -28,6 +29,7 @@ export async function createStdioClient(name: string, config: any): Promise<McpC
 
 export async function createLambdaFunctionClient(name: string, config: any): Promise<McpClient> {
   logger.info(`Initializing lambda function server: ${name}`);
+  logger.debug(`Lambda function config: ${JSON.stringify({ functionName: config.functionName, region: config.region })}`);
   const transport = new LambdaFunctionClientTransport({
     functionName: config.functionName,
     regionName: config.region,
@@ -46,9 +48,11 @@ export async function createLambdaFunctionUrlClient(name: string, config: any):
 
   if (stackName) {
     const outputKey = config.stackUrlOutputKey || config.stack_url_output_key || "FunctionUrl";
+    logger.debug(`Fetching function URL from CloudFormation stack: ${stackName}, output: ${outputKey}`);
     functionUrl = await getCloudFormationOutput(stackName, outputKey, region);
   }
 
+  logger.debug(`Lambda function URL: ${functionUrl}, region: ${region}`);
   const transport = new StreamableHTTPClientWithSigV4Transport(new URL(functionUrl), { region, service: "lambda" });
   return new McpClient({ transport });
 }
@@ -68,13 +72,18 @@ export async function createAutomatedOAuthClient(name: string, config: any): Pro
   const authStackName = config.authStackName || config.auth_stack_name || "LambdaMcpServer-Auth";
   const authStackRegion = config.authStackRegion || config.auth_stack_region || "us-west-2";
 
+  logger.debug(`Fetching server URL for ${name}...`);
   const serverUrl = serverStackName
     ? await getCloudFormationOutput(serverStackName, serverStackUrlOutputKey, serverStackRegion)
     : await getSsmParameter(serverSsmParameterName!, serverSsmRegion);
+  logger.debug(`Server URL: ${serverUrl}`);
 
+  logger.debug(`Fetching OAuth credentials from stack: ${authStackName}`);
   const clientId = await getCloudFormationOutput(authStackName, "AutomatedOAuthClientId", authStackRegion);
   const clientSecret = await getClientSecret(authStackName, authStackRegion);
+  logger.debug(`OAuth client ID: ${clientId}`);
 
+  logger.debug(`Creating OAuth transport for ${name}...`);
   const transport = await createAutomatedOAuthTransport(serverUrl, clientId, clientSecret);
 
   return new McpClient({ transport });