@tyvm/knowhow 0.0.111 → 0.0.113

package/src/processors/CustomVariables.ts

@@ -2,6 +2,7 @@ import { Message } from "../clients/types";
 import { MessageProcessorFunction } from "../services/MessageProcessor";
 import { ToolsService } from "../services";
 import { Tool } from "../clients";
+import { ToolCall } from "../clients/types";
 
 interface VariableStorage {
   [name: string]: any;
@@ -238,6 +239,180 @@ export class CustomVariables {
     };
   }
 
+  /**
+   * Extracts all string values from a JSON-parsed object (recursively)
+   */
+  private extractStringValues(obj: any, results: string[] = []): string[] {
+    if (typeof obj === "string") {
+      results.push(obj);
+    } else if (Array.isArray(obj)) {
+      for (const item of obj) {
+        this.extractStringValues(item, results);
+      }
+    } else if (obj && typeof obj === "object") {
+      for (const val of Object.values(obj)) {
+        this.extractStringValues(val, results);
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Collects all large string values from tool calls, keyed by tool name.
+   * Returns an array of {value, toolName} pairs.
+   */
+  private collectToolCallStrings(
+    messages: Message[],
+    minLength: number
+  ): Array<{ value: string; toolName: string }> {
+    const collected: Array<{ value: string; toolName: string }> = [];
+    for (const message of messages) {
+      if (!message.tool_calls) continue;
+      for (const toolCall of message.tool_calls) {
+        const strings = this.getToolCallStrings(toolCall);
+        for (const str of strings) {
+          if (str.length >= minLength) {
+            collected.push({ value: str, toolName: toolCall.function.name });
+          }
+        }
+      }
+    }
+    return collected;
+  }
+
+  /**
+   * Finds the longest common substring between two strings that is >= minLength.
+   * Returns the substring or null if none found.
+   */
+  private longestCommonSubstring(a: string, b: string, minLength: number): string | null {
+    let best = "";
+    for (let i = 0; i < a.length - minLength + 1; i++) {
+      for (let j = a.length; j > i + minLength - 1; j--) {
+        const sub = a.slice(i, j);
+        if (sub.length <= best.length) break; // already found longer
+        if (b.includes(sub)) {
+          best = sub;
+          break;
+        }
+      }
+    }
+    return best.length >= minLength ? best : null;
+  }
+
+  /**
+   * Extracts all string values from a tool call's arguments
+   */
+  private getToolCallStrings(toolCall: ToolCall): string[] {
+    try {
+      const parsed = JSON.parse(toolCall.function.arguments);
+      return this.extractStringValues(parsed);
+    } catch {
+      // If not JSON, treat the whole arguments string as a single value
+      return [toolCall.function.arguments];
+    }
+  }
+
+  /**
+   * Creates a processor that scans messages for repeated large string values
+   * in tool call arguments, and appends a hint suggesting variable storage.
+   *
+   * This helps the LLM discover that it can avoid re-outputting long strings
+   * (e.g. JWTs, file contents) by storing them once with setVariable or
+   * storeToolCallToVariable and then referencing them via {{varName}}.
+   */
+  createRepetitionHintProcessor(options: {
+    minLength?: number;       // Minimum string length to consider (default: 50)
+    minRepetitions?: number;  // Minimum occurrences to trigger hint (default: 2)
+    minSubstringLength?: number; // Minimum repeated substring length (default: 50)
+    recentMessagesWindow?: number; // Only scan the last N messages (default: 10)
+  } = {}): MessageProcessorFunction {
+    const minLength = options.minLength ?? 50;
+    const minRepetitions = options.minRepetitions ?? 2;
+    const minSubstringLength = options.minSubstringLength ?? 50;
+    const recentMessagesWindow = options.recentMessagesWindow ?? 10;
+
+    return async (originalMessages: Message[], modifiedMessages: Message[]) => {
+      // Count occurrences of each string value across all tool call arguments
+      const stringCounts = new Map<string, { count: number; toolNames: Set<string> }>();
+
+      // Only scan the most recent N messages to keep cost bounded
+      const recentMessages = modifiedMessages.slice(-recentMessagesWindow);
+
+      // Step 1: exact full-string matches
+      const toolStrings = this.collectToolCallStrings(recentMessages, minLength);
+
+      for (const { value, toolName } of toolStrings) {
+        const existing = stringCounts.get(value);
+        if (existing) {
+          existing.count++;
+          existing.toolNames.add(toolName);
+        } else {
+          stringCounts.set(value, { count: 1, toolNames: new Set([toolName]) });
+        }
+      }
+
+      // Step 2: detect repeated substrings across different full strings
+      // e.g. the same JWT embedded in many different commands
+      const substringCounts = new Map<string, { count: number; toolNames: Set<string> }>();
+
+      for (let i = 0; i < toolStrings.length; i++) {
+        for (let j = i + 1; j < toolStrings.length; j++) {
+          const a = toolStrings[i];
+          const b = toolStrings[j];
+          // Skip if the full strings are identical (already counted above)
+          if (a.value === b.value) continue;
+
+          const common = this.longestCommonSubstring(a.value, b.value, minSubstringLength);
+          if (common) {
+            const existing = substringCounts.get(common);
+            if (existing) {
+              existing.count++;
+              existing.toolNames.add(a.toolName);
+              existing.toolNames.add(b.toolName);
+            } else {
+              substringCounts.set(common, {
+                count: 1,
+                toolNames: new Set([a.toolName, b.toolName]),
+              });
+            }
+          }
+        }
+      }
+
+      // Merge substring counts: count = number of unique pairs, so count+1 = occurrences
+      for (const [sub, info] of substringCounts.entries()) {
+        if (info.count + 1 >= minRepetitions) {
+          const existing = stringCounts.get(sub);
+          if (!existing) {
+            stringCounts.set(sub, { count: info.count + 1, toolNames: info.toolNames });
+          }
+        }
+      }
+
+      // Find entries that exceed the repetition threshold
+      const repeatedTools: string[] = [];
+      for (const [str, info] of stringCounts.entries()) {
+        if (info.count >= minRepetitions) {
+          for (const toolName of info.toolNames) {
+            if (!repeatedTools.includes(toolName)) {
+              repeatedTools.push(toolName);
+            }
+          }
+        }
+      }
+
+      if (repeatedTools.length > 0) {
+        modifiedMessages.push({
+          role: "user",
+          content:
+            `⚠️ Tool inputs have large repetitions detected in: ${repeatedTools.join(", ")}. ` +
+            `Consider storing repeated values with \`setVariable\` or \`storeToolCallToVariable\`, ` +
+            `then reference them via {{variableName}} in future tool calls to avoid re-outputting large strings.`,
+        });
+      }
+    };
+  }
+
   /**
    * Registers all custom variable tools with the ToolsService
    */

package/src/services/EventService.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
 import { IAgent } from "../agents/interface";
+import { logger } from "../logger";
 
 export type LogLevel = "info" | "warn" | "error";
 
@@ -36,9 +37,9 @@ type ManagedListenerRecord = {
 /**
  * Default console handler for plugin:log events.
  * Active when no renderer has taken over (e.g. worker mode, CLI before chat starts).
- * Can be suppressed by calling suppressDefaultLogger() when a renderer is active.
+ * Respects logger.silence() — if the logger is silenced, this handler is a no-op.
  *
- * IMPORTANT: Uses process.stdout/stderr directly to avoid infinite recursion
+ * Uses process.stdout/stderr directly to avoid infinite recursion
  * with logger.installConsoleOverload() which overrides console.log/warn.
  */
 function defaultConsoleLogHandler(event: {
@@ -46,6 +47,7 @@ function defaultConsoleLogHandler(event: {
   message: string;
   level: LogLevel;
 }): void {
+  if (logger.isSilenced()) return;
   const prefix = event.source ? `[${event.source}] ` : "";
   const line = `${prefix}${event.message}\n`;
   switch (event.level) {
@@ -63,8 +65,6 @@ function defaultConsoleLogHandler(event: {
 export class EventService extends EventEmitter {
   private blockingHandlers: Map<string, EventHandler[]> = new Map();
   private managedListeners: Map<string, ManagedListenerRecord> = new Map();
-  private defaultLoggerActive = true;
-  private boundDefaultLogHandler = defaultConsoleLogHandler;
 
   eventTypes = {
     agentMsg: "agent:msg",
@@ -76,35 +76,7 @@ export class EventService extends EventEmitter {
   constructor() {
     super();
     this.setMaxListeners(100);
-    // Register the default console logger so Events.log() always produces output
-    // even before a renderer is attached (worker mode, module loading, etc.)
-    this.on(this.eventTypes.pluginLog, this.boundDefaultLogHandler);
-  }
-
-  /**
-   * Suppress the default console logger.
-   * Call this when a renderer has taken over and will handle plugin:log events.
-   * This prevents double-printing when both the renderer and the default handler fire.
-   */
-  suppressDefaultLogger(): void {
-    if (this.defaultLoggerActive) {
-      this.removeListener(
-        this.eventTypes.pluginLog,
-        this.boundDefaultLogHandler
-      );
-      this.defaultLoggerActive = false;
-    }
-  }
-
-  /**
-   * Restore the default console logger.
-   * Call this when the renderer is torn down.
-   */
-  restoreDefaultLogger(): void {
-    if (!this.defaultLoggerActive) {
-      this.on(this.eventTypes.pluginLog, this.boundDefaultLogHandler);
-      this.defaultLoggerActive = true;
-    }
+    this.on(this.eventTypes.pluginLog, defaultConsoleLogHandler);
   }
 
   /**

package/src/utils/index.ts

@@ -40,6 +40,7 @@ export const setOnNewHistoryEntry = (
   inputQueue.setOnNewEntry(callback);
 };
 
+
 export const Marked = marked;
 
 export function dotp(x, y) {

package/tests/fixtures/fake-secret.txt

@@ -0,0 +1 @@
+eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmYWtlLXVzZXItaWQiLCJuYW1lIjoiRmFrZSBVc2VyIiwiaWF0IjoxNTE2MjM5MDIyfQ.FAKE_SECRET_DO_NOT_USE

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

@@ -98,7 +98,7 @@ describe("XAI (Grok) Modalities", () => {
     const dataUrl = `data:image/png;base64,${base64Image}`;
 
     const response = await client.createCompletion("xai", {
-      model: Models.xai.Grok2Vision1212,
+      model: Models.xai.Grok_4_20_NonReasoning,
       messages: [
         {
           role: "user",
@@ -199,42 +199,42 @@ describe("XAI (Grok) Modalities", () => {
         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) {
+      // Helper: poll a known job ID via client until done, then save results
+      async function pollAndSave(jobId: string) {
         const maxPollingTime = 20 * 60 * 1000; // 20 minutes
         const pollingInterval = 5000; // 5 seconds
         const startTime = Date.now();
 
-        console.log(`⏳ Polling request ID: ${requestId}`);
+        console.log(`⏳ Polling job ID: ${jobId}`);
 
         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}` } }
+          const status = await client.getVideoStatus("xai", { jobId });
+          console.log(
+            `   Status: ${status.status}, has data: ${!!status.data?.length}`
           );
 
-          if (!pollResponse.ok) {
-            const errorText = await pollResponse.text();
-            throw new Error(`XAI video polling failed: ${pollResponse.status} ${errorText}`);
+          if (status.status === "failed") {
+            throw new Error(
+              `XAI video generation failed: ${status.error || "unknown error"}`
+            );
           }
 
-          const pollData = await pollResponse.json();
-          console.log(`   Status: ${pollData.status || "unknown"}, has video: ${!!pollData.video}`);
+          if (status.status === "expired") {
+            throw new Error("XAI video generation request expired");
+          }
 
-          // XAI returns video data directly (no status:"done") when complete
-          if (pollData.video?.url) {
-            const videoUrl = pollData.video.url;
+          if (status.status === "completed" && status.data?.[0]?.url) {
+            const videoUrl = status.data[0].url;
             const outputContent = [
               `Generated at: ${new Date().toISOString()}`,
               `Prompt: ${prompt}`,
-              `Request ID: ${requestId}`,
+              `Job ID: ${jobId}`,
               `Video URL: ${videoUrl}`,
             ].join("\n");
             fs.writeFileSync(outputPath, outputContent);
@@ -243,61 +243,48 @@ describe("XAI (Grok) Modalities", () => {
 
             // 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)}`);
+            return;
           }
-          // pending – keep polling
+          // queued / in_progress – keep polling
         }
 
-        throw new Error("XAI video generation timed out after 20 minutes of 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 we already have a job 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);
+        const jobId = fs.readFileSync(jobIdPath, "utf8").trim();
+        console.log(`🔄 Resuming poll for existing job ID: ${jobId}`);
+        await pollAndSave(jobId);
         expect(fs.existsSync(outputPath)).toBe(true);
         return;
       }
 
-      // Otherwise start a new job
+      // Otherwise start a new job via the client
       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",
-        }),
+      const response = await client.createVideoGeneration("xai", {
+        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)}`);
+      const jobId = response.jobId;
+      if (!jobId) {
+        throw new Error(
+          `No jobId returned from video generation: ${JSON.stringify(response)}`
+        );
       }
 
-      // 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})`);
+      // Persist the job ID so subsequent runs can resume if this run times out
+      fs.writeFileSync(jobIdPath, jobId);
+      console.log(`📝 Job ID saved to: ${jobIdPath} (ID: ${jobId})`);
+      console.log(`   Estimated cost: $${response.usd_cost?.toFixed(6)}`);
 
-      await pollAndSave(requestId);
+      await pollAndSave(jobId);
 
       expect(fs.existsSync(outputPath)).toBe(true);
     },