@tyvm/knowhow 0.0.69 → 0.0.70

package/tests/manual/modalities/streaming.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Streaming Text Manual Test
+ *
+ * Tests streaming text generation across all providers:
+ *  1. OpenAI - GPT-4o streaming
+ *  2. Anthropic - Claude streaming
+ *  3. Google - Gemini streaming
+ *  4. XAI - Grok streaming
+ *
+ * Run with:
+ *   npx jest tests/manual/modalities/streaming.test.ts --testTimeout=120000
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { AIClient } from "../../../src/clients";
+import { Models } from "../../../src/types";
+
+const OUTPUT_DIR = path.join(__dirname, "outputs", "streaming");
+
+function ensureOutputDir() {
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+describe("Streaming Text Generation", () => {
+  let client: AIClient;
+
+  beforeAll(() => {
+    ensureOutputDir();
+    client = new AIClient();
+  });
+
+  // ─── 1. OpenAI Streaming ────────────────────────────────────────────────────
+
+  test("1. OpenAI GPT-4o – streaming text generation", async () => {
+    const outputPath = path.join(OUTPUT_DIR, "openai-streaming.txt");
+    if (fs.existsSync(outputPath)) {
+      console.log(`Skipping: output already exists at ${outputPath}`);
+      return;
+    }
+
+    if (!process.env.OPENAI_KEY) {
+      console.log("Skipping: OPENAI_KEY not set");
+      return;
+    }
+
+    const prompt = "Count from 1 to 10, one number per line.";
+    
+    // Use the raw OpenAI client for streaming
+    const openaiClient = client.clients.openai as any;
+    if (!openaiClient) {
+      console.log("Skipping: OpenAI client not available");
+      return;
+    }
+
+    const stream = await openaiClient.client.chat.completions.create({
+      model: Models.openai.GPT_4o_Mini,
+      messages: [{ role: "user", content: prompt }],
+      stream: true,
+      max_tokens: 100,
+    });
+
+    let fullText = "";
+    const chunks: string[] = [];
+
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || "";
+      if (content) {
+        fullText += content;
+        chunks.push(content);
+      }
+    }
+
+    fs.writeFileSync(
+      outputPath,
+      `Full text:\n${fullText}\n\nChunks (${chunks.length}):\n${chunks.join(" | ")}`
+    );
+
+    console.log(`✅ OpenAI streaming completed`);
+    console.log(`   Output saved to: ${outputPath}`);
+    console.log(`   Total chunks: ${chunks.length}`);
+    console.log(`   Full text: ${fullText.substring(0, 100)}...`);
+
+    expect(fullText).toBeTruthy();
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(fullText).toContain("1");
+    expect(fullText).toContain("10");
+  }, 60000);
+
+  // ─── 2. Anthropic Streaming ─────────────────────────────────────────────────
+
+  test("2. Anthropic Claude – streaming text generation", async () => {
+    const outputPath = path.join(OUTPUT_DIR, "anthropic-streaming.txt");
+    if (fs.existsSync(outputPath)) {
+      console.log(`Skipping: output already exists at ${outputPath}`);
+      return;
+    }
+
+    if (!process.env.ANTHROPIC_API_KEY) {
+      console.log("Skipping: ANTHROPIC_API_KEY not set");
+      return;
+    }
+
+    const prompt = "Count from 1 to 10, one number per line.";
+
+    const anthropicClient = client.clients.anthropic as any;
+    if (!anthropicClient) {
+      console.log("Skipping: Anthropic client not available");
+      return;
+    }
+
+    const stream = await anthropicClient.client.messages.create({
+      model: Models.anthropic.Haiku4_5,
+      max_tokens: 100,
+      messages: [{ role: "user", content: prompt }],
+      stream: true,
+    });
+
+    let fullText = "";
+    const chunks: string[] = [];
+
+    for await (const chunk of stream) {
+      if (
+        chunk.type === "content_block_delta" &&
+        chunk.delta.type === "text_delta"
+      ) {
+        const content = chunk.delta.text;
+        if (content) {
+          fullText += content;
+          chunks.push(content);
+        }
+      }
+    }
+
+    fs.writeFileSync(
+      outputPath,
+      `Full text:\n${fullText}\n\nChunks (${chunks.length}):\n${chunks.join(" | ")}`
+    );
+
+    console.log(`✅ Anthropic streaming completed`);
+    console.log(`   Output saved to: ${outputPath}`);
+    console.log(`   Total chunks: ${chunks.length}`);
+    console.log(`   Full text: ${fullText.substring(0, 100)}...`);
+
+    expect(fullText).toBeTruthy();
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(fullText).toContain("1");
+    expect(fullText).toContain("10");
+  }, 60000);
+
+  // ─── 3. Google Gemini Streaming ─────────────────────────────────────────────
+
+  test("3. Google Gemini – streaming text generation", async () => {
+    const outputPath = path.join(OUTPUT_DIR, "google-streaming.txt");
+    if (fs.existsSync(outputPath)) {
+      console.log(`Skipping: output already exists at ${outputPath}`);
+      return;
+    }
+
+    if (!process.env.GEMINI_API_KEY) {
+      console.log("Skipping: GEMINI_API_KEY not set");
+      return;
+    }
+
+    const prompt = "Count from 1 to 10, one number per line.";
+
+    const geminiClient = client.clients.google as any;
+    if (!geminiClient) {
+      console.log("Skipping: Google client not available");
+      return;
+    }
+
+    const result = await geminiClient.client.models.generateContentStream({
+      model: Models.google.Gemini_20_Flash,
+      contents: [{ role: 'user', parts: [{ text: prompt }] }]
+    });
+
+    let fullText = "";
+    const chunks: string[] = [];
+
+    for await (const chunk of result) {
+      const chunkText = chunk.candidates?.[0]?.content?.parts?.[0]?.text || '';
+      if (chunkText) {
+        fullText += chunkText;
+        chunks.push(chunkText);
+      }
+    }
+
+    fs.writeFileSync(
+      outputPath,
+      `Full text:\n${fullText}\n\nChunks (${chunks.length}):\n${chunks.join(" | ")}`
+    );
+
+    console.log(`✅ Google Gemini streaming completed`);
+    console.log(`   Output saved to: ${outputPath}`);
+    console.log(`   Total chunks: ${chunks.length}`);
+    console.log(`   Full text: ${fullText.substring(0, 100)}...`);
+
+    expect(fullText).toBeTruthy();
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(fullText).toContain("1");
+    expect(fullText).toContain("10");
+  }, 60000);
+
+  // ─── 4. XAI Grok Streaming ──────────────────────────────────────────────────
+
+  test("4. XAI Grok – streaming text generation", async () => {
+    const outputPath = path.join(OUTPUT_DIR, "xai-streaming.txt");
+    if (fs.existsSync(outputPath)) {
+      console.log(`Skipping: output already exists at ${outputPath}`);
+      return;
+    }
+
+    if (!process.env.XAI_API_KEY) {
+      console.log("Skipping: XAI_API_KEY not set");
+      return;
+    }
+
+    const prompt = "Count from 1 to 10, one number per line.";
+
+    const xaiClient = client.clients.xai as any;
+    if (!xaiClient) {
+      console.log("Skipping: XAI client not available");
+      return;
+    }
+
+    const stream = await xaiClient.client.chat.completions.create({
+      model: Models.xai.Grok3MiniFastBeta,
+      messages: [{ role: "user", content: prompt }],
+      stream: true,
+      max_tokens: 100,
+    });
+
+    let fullText = "";
+    const chunks: string[] = [];
+
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || "";
+      if (content) {
+        fullText += content;
+        chunks.push(content);
+      }
+    }
+
+    fs.writeFileSync(
+      outputPath,
+      `Full text:\n${fullText}\n\nChunks (${chunks.length}):\n${chunks.join(" | ")}`
+    );
+
+    console.log(`✅ XAI Grok streaming completed`);
+    console.log(`   Output saved to: ${outputPath}`);
+    console.log(`   Total chunks: ${chunks.length}`);
+    console.log(`   Full text: ${fullText.substring(0, 100)}...`);
+
+    expect(fullText).toBeTruthy();
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(fullText).toContain("1");
+    expect(fullText).toContain("10");
+  }, 60000);
+});

package/tests/manual/modalities/xai.modalities.test.ts

@@ -0,0 +1,307 @@
+/**
+ * XAI (Grok) Modalities Manual Test
+ *
+ * Tests:
+ *  1. Image generation (grok-imagine-image) → saved to disk
+ *  2. Vision – send generated image to Grok vision model and describe it
+ *  3. Audio generation – not supported by XAI (documented)
+ *  4. Audio transcription – not supported by XAI (documented)
+ *  5. Video generation (grok-imagine-video) → polls until done, saves URL to disk
+ *
+ * Run with:
+ *   npx jest tests/manual/modalities/xai.modalities.test.ts --testTimeout=720000
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { AIClient } from "../../../src/clients";
+import { Models } from "../../../src/types";
+
+const OUTPUT_DIR = path.join(__dirname, "outputs", "xai");
+
+function ensureOutputDir() {
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+describe("XAI (Grok) Modalities", () => {
+  let client: AIClient;
+
+  beforeAll(() => {
+    if (!process.env.XAI_API_KEY) {
+      console.warn("XAI_API_KEY not set – skipping XAI modality tests");
+    }
+    ensureOutputDir();
+    client = new AIClient();
+  });
+
+  // ─── 1. Image Generation (grok-imagine-image) ────────────────────────────────
+
+  test("1. XAI grok-imagine-image – generate image and save to disk", async () => {
+    if (!process.env.XAI_API_KEY) {
+      console.log("Skipping: XAI_API_KEY not set");
+      return;
+    }
+
+    const prompt =
+      "A breathtaking aerial view of a neon-lit futuristic city at night, " +
+      "flying cars, holographic billboards, cyberpunk aesthetic";
+
+    const response = await client.createImageGeneration("xai", {
+      model: "grok-imagine-image",
+      prompt,
+      n: 1,
+      response_format: "b64_json",
+    });
+
+    expect(response.data.length).toBeGreaterThan(0);
+
+    const imageData = response.data[0];
+    const outputPath = path.join(OUTPUT_DIR, "aurora-output.png");
+
+    if (imageData.b64_json) {
+      const buffer = Buffer.from(imageData.b64_json, "base64");
+      fs.writeFileSync(outputPath, buffer);
+      console.log(`✅ Image saved to: ${outputPath}`);
+      console.log(`   Size: ${buffer.length} bytes`);
+    } else if (imageData.url) {
+      fs.writeFileSync(
+        path.join(OUTPUT_DIR, "aurora-output-url.txt"),
+        imageData.url
+      );
+      console.log(`✅ Image URL saved: ${imageData.url}`);
+    }
+
+    console.log(`   Estimated cost: $${response.usd_cost?.toFixed(6)}`);
+
+    expect(response.created).toBeGreaterThan(0);
+    expect(response.data.length).toBeGreaterThan(0);
+  }, 90000);
+
+  // ─── 2. Vision – send generated image to Grok Vision ────────────────────────
+
+  test("2. XAI Grok Vision – describe the generated image", async () => {
+    if (!process.env.XAI_API_KEY) {
+      console.log("Skipping: XAI_API_KEY not set");
+      return;
+    }
+
+    const imagePath = path.join(OUTPUT_DIR, "aurora-output.png");
+    if (!fs.existsSync(imagePath)) {
+      console.log(
+        "Skipping: aurora-output.png not found – run image generation test first"
+      );
+      return;
+    }
+
+    const imageBuffer = fs.readFileSync(imagePath);
+    const base64Image = imageBuffer.toString("base64");
+    const dataUrl = `data:image/png;base64,${base64Image}`;
+
+    const response = await client.createCompletion("xai", {
+      model: Models.xai.Grok2Vision1212,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: "Please describe this image in detail. What do you see?",
+            },
+            {
+              type: "image_url",
+              image_url: { url: dataUrl },
+            },
+          ],
+        },
+      ],
+      max_tokens: 500,
+    });
+
+    const description = response.choices[0]?.message?.content || "";
+    const outputPath = path.join(OUTPUT_DIR, "vision-description.txt");
+    fs.writeFileSync(outputPath, description);
+
+    console.log(`✅ Vision description saved to: ${outputPath}`);
+    console.log(`   Description: ${description.substring(0, 200)}...`);
+    console.log(`   Estimated cost: $${response.usd_cost?.toFixed(6)}`);
+
+    expect(description).toBeTruthy();
+    expect(description.length).toBeGreaterThan(10);
+  }, 60000);
+
+  // ─── 3. Audio Generation – not supported ─────────────────────────────────────
+
+  test("3. XAI Audio Generation – not supported (expected error)", async () => {
+    if (!process.env.XAI_API_KEY) {
+      console.log("Skipping: XAI_API_KEY not set");
+      return;
+    }
+
+    /**
+     * XAI does not support audio generation. The client throws an error.
+     * This test verifies that the error is thrown correctly and documents
+     * the limitation.
+     */
+    await expect(
+      client.createAudioGeneration("xai", {
+        model: "xai-tts",
+        input: "Hello world",
+        voice: "default",
+      })
+    ).rejects.toThrow();
+
+    console.log(
+      "✅ XAI correctly throws an error for unsupported audio generation"
+    );
+  }, 15000);
+
+  // ─── 4. Audio Transcription – not supported ───────────────────────────────────
+
+  test("4. XAI Audio Transcription – not supported (expected error)", async () => {
+    if (!process.env.XAI_API_KEY) {
+      console.log("Skipping: XAI_API_KEY not set");
+      return;
+    }
+
+    /**
+     * XAI does not support audio transcription. This test verifies the error.
+     */
+    const fakeStream = { name: "test.mp3" } as any;
+
+    await expect(
+      client.createAudioTranscription("xai", {
+        file: fakeStream,
+        model: "whisper",
+      })
+    ).rejects.toThrow();
+
+    console.log(
+      "✅ XAI correctly throws an error for unsupported audio transcription"
+    );
+  }, 15000);
+
+  // ─── 5. Video Generation (grok-imagine-video) ────────────────────────────────
+
+  test(
+    "5. XAI grok-imagine-video – generate video and save URL to disk",
+    async () => {
+      if (!process.env.XAI_API_KEY) {
+        console.log("Skipping: XAI_API_KEY not set");
+        return;
+      }
+
+      const outputPath = path.join(OUTPUT_DIR, "video-output.txt");
+      const jobIdPath = path.join(OUTPUT_DIR, "video-job-id.txt");
+
+      // If final output already exists, skip entirely
+      if (fs.existsSync(outputPath)) {
+        console.log(`⏭️  Skipping: output already exists at ${outputPath}`);
+        return;
+      }
+
+      const apiKey = process.env.XAI_API_KEY!;
+      const prompt =
+        "A cyberpunk cityscape at night with flying cars and neon lights, " +
+        "cinematic camera slowly panning upward to reveal the skyline";
+
+      // Helper: poll a known request ID until done, then save results
+      async function pollAndSave(requestId: string) {
+        const maxPollingTime = 20 * 60 * 1000; // 20 minutes
+        const pollingInterval = 5000; // 5 seconds
+        const startTime = Date.now();
+
+        console.log(`⏳ Polling request ID: ${requestId}`);
+
+        while (Date.now() - startTime < maxPollingTime) {
+          await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+
+          const pollResponse = await fetch(
+            `https://api.x.ai/v1/videos/${requestId}`,
+            { headers: { Authorization: `Bearer ${apiKey}` } }
+          );
+
+          if (!pollResponse.ok) {
+            const errorText = await pollResponse.text();
+            throw new Error(`XAI video polling failed: ${pollResponse.status} ${errorText}`);
+          }
+
+          const pollData = await pollResponse.json();
+          console.log(`   Status: ${pollData.status || "unknown"}, has video: ${!!pollData.video}`);
+
+          // XAI returns video data directly (no status:"done") when complete
+          if (pollData.video?.url) {
+            const videoUrl = pollData.video.url;
+            const outputContent = [
+              `Generated at: ${new Date().toISOString()}`,
+              `Prompt: ${prompt}`,
+              `Request ID: ${requestId}`,
+              `Video URL: ${videoUrl}`,
+            ].join("\n");
+            fs.writeFileSync(outputPath, outputContent);
+            console.log(`✅ Video URL saved to: ${outputPath}`);
+            console.log(`   Video URL: ${videoUrl}`);
+
+            // Clean up job ID file
+            if (fs.existsSync(jobIdPath)) fs.unlinkSync(jobIdPath);
+            return pollData;
+          } else if (pollData.status === "expired") {
+            throw new Error("XAI video generation request expired");
+          } else if (pollData.status === "failed") {
+            throw new Error(`XAI video generation failed: ${JSON.stringify(pollData)}`);
+          }
+          // pending – keep polling
+        }
+
+        throw new Error("XAI video generation timed out after 20 minutes of polling");
+      }
+
+      // If we already have a request ID from a previous (timed-out) run, resume
+      if (fs.existsSync(jobIdPath)) {
+        const requestId = fs.readFileSync(jobIdPath, "utf8").trim();
+        console.log(`🔄 Resuming poll for existing request ID: ${requestId}`);
+        await pollAndSave(requestId);
+        expect(fs.existsSync(outputPath)).toBe(true);
+        return;
+      }
+
+      // Otherwise start a new job
+      console.log("⏳ Submitting XAI video generation job...");
+
+      const startResponse = await fetch("https://api.x.ai/v1/videos/generations", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: "grok-imagine-video",
+          prompt,
+          duration: 5,
+          aspect_ratio: "16:9",
+        }),
+      });
+
+      if (!startResponse.ok) {
+        const errorText = await startResponse.text();
+        throw new Error(`XAI video generation start failed: ${startResponse.status} ${errorText}`);
+      }
+
+      const startData = await startResponse.json();
+      const requestId = startData.request_id;
+
+      if (!requestId) {
+        throw new Error(`No request_id in response: ${JSON.stringify(startData)}`);
+      }
+
+      // Persist the request ID so subsequent runs can resume if this run times out
+      fs.writeFileSync(jobIdPath, requestId);
+      console.log(`📝 Request ID saved to: ${jobIdPath} (ID: ${requestId})`);
+
+      await pollAndSave(requestId);
+
+      expect(fs.existsSync(outputPath)).toBe(true);
+    },
+    // 25 minute timeout
+    1500000
+  );
+});

package/tests/plugins/language/languagePlugin-content-triggers.test.ts

@@ -82,7 +82,7 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
 
     mockedReadFile.mockResolvedValue(Buffer.from(fileContentWithTests));
     mockedConfig.mockResolvedValue({
-      plugins: [],
+      plugins: { enabled: [], disabled: [] },
       modules: [],
       promptsDir: ".knowhow/prompts",
       sources: [],
@@ -153,7 +153,7 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
 
     mockedReadFile.mockResolvedValue(Buffer.from(fileContent));
     mockedConfig.mockResolvedValue({
-      plugins: [],
+      plugins: { enabled: [], disabled: [] },
       modules: [],
       promptsDir: ".knowhow/prompts",
       sources: [],
@@ -196,7 +196,7 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
     // Mock readFile to throw an error
     mockedReadFile.mockRejectedValue(new Error("File not found"));
     mockedConfig.mockResolvedValue({
-      plugins: [],
+      plugins: { enabled: [], disabled: [] },
       modules: [],
       promptsDir: ".knowhow/prompts",
       sources: [],
@@ -245,7 +245,7 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
 
     mockedReadFile.mockResolvedValue(Buffer.from(fileContent));
     mockedConfig.mockResolvedValue({
-      plugins: [],
+      plugins: { enabled: [], disabled: [] },
       modules: [],
       promptsDir: ".knowhow/prompts",
       sources: [],
@@ -298,7 +298,7 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
 
     mockedReadFile.mockResolvedValue(Buffer.from(fileContent));
     mockedConfig.mockResolvedValue({
-      plugins: [],
+      plugins: { enabled: [], disabled: [] },
       modules: [],
       promptsDir: ".knowhow/prompts",
       sources: [],

package/tests/plugins/language/languagePlugin-integration.test.ts

@@ -57,7 +57,7 @@ describe("LanguagePlugin - Integration Tests", () => {
 
     // Mock config functions
     (getConfig as jest.MockedFunction<typeof getConfig>).mockResolvedValue({
-      plugins: [],
+      plugins: { enabled: [], disabled: [] },
     } as Config);
 
     // Setup language configuration with testing term

package/tests/plugins/language/languagePlugin.test.ts

@@ -80,7 +80,9 @@ describe("LanguagePlugin", () => {
     mockPluginService.listPlugins = mockListPlugins;
     mockPluginService.call = mockCall;
 
-    mockedConfig.mockResolvedValue({ plugins: ["github", "asana"] } as Config);
+    mockedConfig.mockResolvedValue({
+      plugins: { enabled: ["github", "asana"], disabled: [] },
+    } as Config);
     mockedLanguageConfig.mockResolvedValue({
       test: {
         events: [],
@@ -162,7 +164,9 @@ describe("LanguagePlugin", () => {
     });
 
     test("should handle file:post-edit event and emit agent:msg when file pattern matches", async () => {
-      mockedConfig.mockResolvedValue({ plugins: ["github"] } as Config);
+      mockedConfig.mockResolvedValue({
+        plugins: { enabled: ["github"], disabled: [] },
+      } as Config);
       mockedLanguageConfig.mockResolvedValue({
         "**/*.ts": {
           events: ["file:post-edit"],
@@ -241,9 +245,11 @@ describe("LanguagePlugin", () => {
     });
 
     test("should handle multiple matching patterns for a single file", async () => {
-      mockedConfig.mockResolvedValue({ plugins: [] } as Config);
+      mockedConfig.mockResolvedValue({
+        plugins: { enabled: [], disabled: [] },
+      } as Config);
       mockedLanguageConfig.mockResolvedValue({
-        "*.ts": {
+        "**/*.ts": {
           events: ["file:post-edit"],
           sources: [{ kind: "text", data: ["TypeScript context"] }],
         },
@@ -308,9 +314,11 @@ describe("LanguagePlugin", () => {
     });
 
     test("should resolve different source types in event context", async () => {
-      mockedConfig.mockResolvedValue({ plugins: ["github"] } as Config);
+      mockedConfig.mockResolvedValue({
+        plugins: { enabled: ["github"], disabled: [] },
+      } as Config);
       mockedLanguageConfig.mockResolvedValue({
-        "*.json": {
+        "package.json": {
           events: ["file:post-edit"],
           sources: [
             { kind: "file", data: ["config/settings.json"] },
@@ -360,9 +368,10 @@ describe("LanguagePlugin", () => {
 
     mockPluginService.listPlugins = mockListPlugins;
 
-    mockedConfig.mockResolvedValue({ plugins: ["github"] } as Config);
+    mockedConfig.mockResolvedValue({
+      plugins: { enabled: ["github"], disabled: [] },
+    } as Config);
     mockedLanguageConfig.mockResolvedValue({});
-
     const languagePlugin = new LanguagePlugin({
       Events: mockEventService,
       Plugins: mockPluginService,

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.69",
+    "version": "0.0.70",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {

package/ts_build/src/agents/base/base.js

@@ -510,7 +510,7 @@ class BaseAgent {
     }
     logStatus() {
         const statusMessage = this.getStatusMessage();
-        console.log(`\n● ${this.name} status: $${this.getTotalCostUsd().toPrecision(3)}\n${statusMessage}`);
+        console.log(`\n● ${this.name} status: ${statusMessage}`);
     }
     addPendingMessage(message) {
         if (this.status === this.eventTypes.done) {