test: raise logLevel above info for tests to clean up output.

Author: bhouston

src/core/executeToolCall.ts

@@ -18,7 +18,6 @@ export const executeToolCall = async (
 
   const tool = tools.find((t) => t.name === toolCall.name);
   if (!tool) {
-    logger.error(`Tool '${toolCall.name}' not found`);
     throw new Error(`No tool with the name '${toolCall.name}' exists.`);
   }
 

src/core/toolAgent.test.ts

@@ -5,7 +5,7 @@ import { Tool } from "./types.js";
 import { Logger } from "../utils/logger.js";
 import { toolAgent } from "./toolAgent.js";
 
-const logger = new Logger({ name: "toolAgent" });
+const logger = new Logger({ name: "toolAgent", logLevel: "warn" });
 
 // Mock configuration for testing
 const testConfig = {
@@ -96,7 +96,7 @@ describe("toolAgent", () => {
         input: { input: "test" },
       },
       [mockTool],
-      logger,
+      logger
     );
 
     expect(result.includes("Processed: test")).toBeTruthy();
@@ -111,8 +111,8 @@ describe("toolAgent", () => {
           input: {},
         },
         [mockTool],
-        logger,
-      ),
+        logger
+      )
     ).rejects.toThrow("No tool with the name 'nonexistentTool' exists.");
   });
 
@@ -142,8 +142,8 @@ describe("toolAgent", () => {
           input: {},
         },
         [errorTool],
-        logger,
-      ),
+        logger
+      )
     ).rejects.toThrow("Deliberate failure");
   });
 
@@ -153,7 +153,7 @@ describe("toolAgent", () => {
       "Test prompt",
       [sequenceCompleteTool],
       logger,
-      testConfig,
+      testConfig
     );
 
     expect(result.result).toBe("Test complete");

src/core/toolAgent.ts

@@ -169,126 +169,114 @@ export const toolAgent = async (
   let totalOutputTokens = 0;
   let interactions = 0;
 
-  try {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) throw new Error(getAnthropicApiKeyError());
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) throw new Error(getAnthropicApiKeyError());
 
-    const client = new Anthropic({ apiKey });
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [{ type: "text", text: initialPrompt }],
-      },
-    ];
+  const client = new Anthropic({ apiKey });
+  const messages: Message[] = [
+    {
+      role: "user",
+      content: [{ type: "text", text: initialPrompt }],
+    },
+  ];
 
-    logger.debug("User message:", initialPrompt);
+  logger.debug("User message:", initialPrompt);
 
-    // Get the system prompt once at the start
-    const systemPrompt = await config.getSystemPrompt();
+  // Get the system prompt once at the start
+  const systemPrompt = await config.getSystemPrompt();
 
-    for (let i = 0; i < config.maxIterations; i++) {
-      logger.verbose(
-        `Requesting completion ${i + 1} with ${messages.length} messages with ${
-          JSON.stringify(messages).length
-        } bytes`
-      );
-
-      interactions++;
-      const response = await client.messages.create({
-        model: config.model,
-        max_tokens: config.maxTokens,
-        temperature: config.temperature,
-        messages,
-        system: systemPrompt,
-        tools: tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          input_schema: t.parameters as Anthropic.Tool.InputSchema,
-        })),
-        tool_choice: { type: "auto" },
-      });
-
-      if (!response.content.length) {
-        const result = {
-          result:
-            "Agent returned empty message implying it is done its given task",
-          tokens: {
-            input: totalInputTokens,
-            output: totalOutputTokens,
-          },
-          interactions,
-        };
-        logger.verbose(
-          `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
-        );
-        return result;
-      }
+  for (let i = 0; i < config.maxIterations; i++) {
+    logger.verbose(
+      `Requesting completion ${i + 1} with ${messages.length} messages with ${
+        JSON.stringify(messages).length
+      } bytes`
+    );
 
-      totalInputTokens += response.usage.input_tokens;
-      totalOutputTokens += response.usage.output_tokens;
+    interactions++;
+    const response = await client.messages.create({
+      model: config.model,
+      max_tokens: config.maxTokens,
+      temperature: config.temperature,
+      messages,
+      system: systemPrompt,
+      tools: tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters as Anthropic.Tool.InputSchema,
+      })),
+      tool_choice: { type: "auto" },
+    });
+
+    if (!response.content.length) {
+      const result = {
+        result:
+          "Agent returned empty message implying it is done its given task",
+        tokens: {
+          input: totalInputTokens,
+          output: totalOutputTokens,
+        },
+        interactions,
+      };
       logger.verbose(
-        `  Token usage: ${response.usage.input_tokens} input, ${response.usage.output_tokens} output`
+        `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
       );
+      return result;
+    }
 
-      const { content, toolCalls } = processResponse(response);
-      messages.push({ role: "assistant", content });
-
-      // Log the assistant's message
-      const assistantMessage = content
-        .filter((c) => c.type === "text")
-        .map((c) => (c as TextContent).text)
-        .join("\\n");
-      if (assistantMessage) {
-        logger.info(assistantMessage);
-      }
+    totalInputTokens += response.usage.input_tokens;
+    totalOutputTokens += response.usage.output_tokens;
+    logger.verbose(
+      `  Token usage: ${response.usage.input_tokens} input, ${response.usage.output_tokens} output`
+    );
 
-      const { sequenceCompleted, completionResult } = await executeTools(
-        toolCalls,
-        tools,
-        messages,
-        logger
-      );
+    const { content, toolCalls } = processResponse(response);
+    messages.push({ role: "assistant", content });
 
-      if (sequenceCompleted) {
-        const result = {
-          result:
-            completionResult ??
-            "Sequence explicitly completed with an empty result",
-          tokens: {
-            input: totalInputTokens,
-            output: totalOutputTokens,
-          },
-          interactions,
-        };
-        logger.verbose(
-          `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
-        );
-        return result;
-      }
+    // Log the assistant's message
+    const assistantMessage = content
+      .filter((c) => c.type === "text")
+      .map((c) => (c as TextContent).text)
+      .join("\\n");
+    if (assistantMessage) {
+      logger.info(assistantMessage);
     }
 
-    logger.warn("Maximum iterations reached");
-    const result = {
-      result:
-        "Maximum sub-agent iterations reach without successful completion",
-      tokens: {
-        input: totalInputTokens,
-        output: totalOutputTokens,
-      },
-      interactions,
-    };
-    logger.verbose(
-      `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
+    const { sequenceCompleted, completionResult } = await executeTools(
+      toolCalls,
+      tools,
+      messages,
+      logger
     );
-    return result;
-  } catch (error) {
-    const errorMessage =
-      error instanceof Error ? error.message : "Unknown error";
-    logger.error(
-      "Agent execution failed",
-      errorMessage,
-      (error as Error)?.stack
-    );
-    throw error;
+
+    if (sequenceCompleted) {
+      const result = {
+        result:
+          completionResult ??
+          "Sequence explicitly completed with an empty result",
+        tokens: {
+          input: totalInputTokens,
+          output: totalOutputTokens,
+        },
+        interactions,
+      };
+      logger.verbose(
+        `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
+      );
+      return result;
+    }
   }
+
+  logger.warn("Maximum iterations reached");
+  const result = {
+    result: "Maximum sub-agent iterations reach without successful completion",
+    tokens: {
+      input: totalInputTokens,
+      output: totalOutputTokens,
+    },
+    interactions,
+  };
+  logger.verbose(
+    `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
+  );
+  return result;
 };

src/tools/interaction/subAgent.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { subAgentTool } from "./subAgent.js";
 import { Logger } from "../../utils/logger.js";
 
-const logger = new Logger({ name: "subAgent" });
+const logger = new Logger({ name: "subAgent", logLevel: "warn" });
 
 // Mock Anthropic client response
 const mockResponse = {

src/tools/io/readFile.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { Logger } from "../../utils/logger.js";
 import { readFileTool } from "./readFile.js";
 
-const logger = new Logger({ name: "readFile" });
+const logger = new Logger({ name: "readFile", logLevel: "warn" });
 
 describe("readFile", () => {
   it("should read a file", async () => {

src/tools/io/updateFile.test.ts

@@ -9,7 +9,7 @@ import { updateFileTool } from "./updateFile.js";
 import { readFileTool } from "./readFile.js";
 import { shellExecuteTool } from "../system/shellExecute.js";
 
-const logger = new Logger({ name: "updateFile" });
+const logger = new Logger({ name: "updateFile", logLevel: "warn" });
 
 describe("updateFile", () => {
   let testDir: string;

src/tools/system/shellExecute.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { Logger } from "../../utils/logger.js";
 import { shellExecuteTool } from "./shellExecute.js";
 
-const logger = new Logger({ name: "shellExecute" });
+const logger = new Logger({ name: "shellExecute", logLevel: "warn" });
 
 describe("shellExecute", () => {
   it("should execute shell commands", async () => {