@tyvm/knowhow 0.0.46 → 0.0.48

package/src/processors/ToolResponseCache.ts

@@ -41,7 +41,7 @@ export class ToolResponseCache {
   /**
    * Recursively searches for JSON strings within an object and parses them
    */
-  private parseNestedJsonStrings(obj: any): any {
+  public parseNestedJsonStrings(obj: any): any {
     if (typeof obj === "string") {
       const parsed = this.tryParseJson(obj);
       if (parsed) {
@@ -68,7 +68,7 @@ export class ToolResponseCache {
   /**
    * Stores a tool response for later manipulation
    */
-  private storeToolResponse(content: string, toolCallId: string): void {
+  public storeToolResponse(content: string, toolCallId: string): void {
     // Always store the original content for later JQ manipulation
     this.storage[toolCallId] = content;
 
@@ -130,17 +130,26 @@ export class ToolResponseCache {
     }
 
     try {
-      // Parse the data as JSON (handles nested JSON strings)
-      const parsedData = this.parseNestedJsonStrings(data);
+      
+      // First parse the stored string as JSON, then handle nested JSON strings
+      const jsonData = this.tryParseJson(data);
+      if (!jsonData) {
+        return `Error: Tool response data is not valid JSON for toolCallId "${toolCallId}"`;
+      }
+      const parsedData = this.parseNestedJsonStrings(jsonData);
 
       // Execute JQ query
       const result = await jq.run(jqQuery, parsedData, { input: "json" });
 
-      // Return the result as a string
+      // Handle the result based on its type
       if (typeof result === "string") {
         return result;
+      } else if (typeof result === "number" || typeof result === "boolean") {
+        return String(result);
+      } else if (result === null) {
+        return "null";
       } else {
-        return JSON.stringify(result, null, 2);
+        return JSON.stringify(result);
       }
     } catch (error: any) {
       // If JQ fails, try to provide helpful error message

package/src/services/EmbeddingService.ts

@@ -1,3 +1,6 @@
+import * as path from "path";
+import { globSync } from "glob";
+
 import {
   Config,
   Embeddable,
@@ -13,10 +16,8 @@ import {
   cosineSimilarity,
 } from "../utils";
 import { summarizeTexts, chunkText } from "../ai";
-import { Plugins } from "../plugins/plugins";
 import { Clients, GenericClient } from "../clients";
-import * as path from "path";
-import glob from "glob";
+import { PluginService } from "..//plugins/plugins";
 
 export type CreateEmbeddingOptions = {
   provider?: string;
@@ -31,13 +32,21 @@ export type EmbedOptions = {
   minLength?: number;
 };
 
+interface EmbeddingServiceContext {
+  config: Config;
+  embeddingClient?: GenericClient;
+  plugins: PluginService;
+}
+
 export class EmbeddingService {
   private config: Config;
   private embeddingClient: GenericClient;
+  private plugins: PluginService;
 
-  constructor(config: Config, embeddingClient: GenericClient) {
-    this.config = config;
-    this.embeddingClient = embeddingClient;
+  constructor(protected context: EmbeddingServiceContext) {
+    this.config = context.config;
+    this.embeddingClient = context.embeddingClient;
+    this.plugins = context.plugins;
   }
 
   setEmbeddingClient(client: GenericClient) {
@@ -102,7 +111,7 @@ export class EmbeddingService {
     }
 
     console.log("Embedding", source.input, "to", source.output);
-    let files = await glob.sync(source.input, { ignore: ignorePattern });
+    let files = await globSync(source.input, { ignore: ignorePattern });
 
     if (source.kind && files.length === 0) {
       files = [source.input];
@@ -193,9 +202,9 @@ export class EmbeddingService {
     const contents = "";
     const ids = [];
 
-    if (Plugins.isPlugin(kind)) {
+    if (this.plugins.isPlugin(kind)) {
       console.log("Embedding with plugin", kind);
-      return Plugins.embed(kind, input);
+      return this.plugins.embed(kind, input);
     }
     switch (kind) {
       case "text":

package/src/services/EventService.ts

@@ -1,11 +1,91 @@
 import { EventEmitter } from "events";
 import { IAgent } from "../agents/interface";
 
+export interface EventHandler {
+  handler: (...args: any[]) => any;
+}
+
 export class EventService extends EventEmitter {
+  private blockingHandlers: Map<string, EventHandler[]> = new Map();
+
   constructor() {
     super();
   }
 
+  /**
+   * Register an event handler as blocking or non-blocking
+   * @param event The event name
+   * @param handler The event handler function
+   * @param isBlocking Whether this handler should be blocking
+   */
+  onBlocking(event: string, handler: (...args: any[]) => any): void {
+    if (!this.blockingHandlers.has(event)) {
+      this.blockingHandlers.set(event, []);
+    }
+
+    this.blockingHandlers.get(event)!.push({ handler });
+  }
+
+  /**
+   * Emit a blocking event - if any blocking handler throws, execution stops
+   * @param event The event name
+   * @param args Arguments to pass to handlers
+   * @returns Promise that resolves with array of handler results when all handlers complete, or rejects if any blocking handler throws
+   */
+  async emitBlocking(event: string, ...args: any[]): Promise<any[]> {
+    const results: any[] = [];
+
+    const handlers = this.blockingHandlers.get(event) || [];
+
+    for (const { handler } of handlers) {
+      try {
+        const result = handler(...args);
+        if (result instanceof Promise) {
+          const awaitedResult = await result;
+          results.push(awaitedResult);
+        } else {
+          results.push(result);
+        }
+      } catch (error) {
+        // If this is a blocking handler and it throws, stop execution
+        throw error;
+      }
+    }
+
+    this.emit(event, ...args);
+    return results.filter((r) => Boolean(r));
+  }
+
+  /**
+   * Emit a non-blocking event - all handlers run, errors are logged but don't stop execution
+   * @param event The event name
+   * @param args Arguments to pass to handlers
+   * @returns Promise that resolves with array of handler results when all handlers complete
+   */
+  async emitNonBlocking(event: string, ...args: any[]): Promise<any[]> {
+    const handlers = this.blockingHandlers.get(event) || [];
+    const results: any[] = [];
+    for (const { handler } of handlers) {
+      try {
+        const result = handler(...args);
+        if (result instanceof Promise) {
+          const awaitedResult = await result;
+          results.push(awaitedResult);
+        } else {
+          results.push(result);
+        }
+      } catch (error) {
+        console.error(
+          `Non-blocking handler error for event '${event}':`,
+          error
+        );
+      }
+    }
+
+    this.emit(event, ...args);
+    return results.filter((r) => Boolean(r));
+  }
+
   registerAgent(agent: IAgent): void {
     this.emit("agents:register", { name: agent.name, agent });
   }

package/src/services/Mcp.ts

@@ -2,6 +2,7 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import Anthropic from "@anthropic-ai/sdk";
 
+import fs from "fs";
 import { McpConfig } from "../types";
 import { Tool } from "../clients";
 import { getConfig } from "../config";
@@ -79,6 +80,10 @@ export class McpService {
       }
       if (mcp.url) {
         // TODO: also support refresh tokens
+        if (mcp.authorization_token_file) {
+          const token = fs.readFileSync(mcp.authorization_token_file, "utf-8");
+          mcp.authorization_token = token.trim();
+        }
         return new StreamableHTTPClientTransport(new URL(mcp.url), {
           requestInit: {
             headers: {

package/src/services/S3.ts

@@ -8,7 +8,8 @@ import {
   PutObjectCommandInput,
 } from "@aws-sdk/client-s3";
 
-import fs from "fs/promises";
+import * as fs from "fs";
+const fsPromises = fs.promises;
 import { createWriteStream } from "fs";
 import * as path from "path";
 import { pipeline } from "stream";
@@ -30,7 +31,7 @@ export class S3Service {
     bucketName: string,
     key: string
   ): Promise<void> {
-    const fileContent = await fs.readFile(filePath);
+    const fileContent = await fsPromises.readFile(filePath);
 
     const params = {
       Bucket: bucketName,
@@ -80,7 +81,7 @@ export class S3Service {
   ): Promise<void> {
     try {
       const fileStream = createReadStream(filePath);
-      const fileStats = await fs.stat(filePath);
+      const fileStats = await fsPromises.stat(filePath);
 
       const response = await axios.put(presignedUrl, fileStream, {
         headers: {

package/src/services/Tools.ts

@@ -82,49 +82,30 @@ export class ToolsService {
   }
 
   getFunction(name: string) {
-    // return this.functions[name] || allTools.addInternalTools(allTools)[name];
+    // Apply overrides and wrappers before returning (even if no base function exists)
+    if (this.functions[name] || this.originalFunctions[name]) {
+      this.applyOverridesAndWrappers(name);
+    } else {
+      // Check if there are overrides for this name even without a base function
+      const matchingOverride = this.findMatchingOverride(name);
+      if (matchingOverride) {
+        this.functions[name] = matchingOverride.override;
+      } else {
+        return undefined;
+      }
+    }
     return this.functions[name];
   }
 
   setFunction(name: string, func: (...args: any) => any) {
     // Store original function if not already stored
     if (!this.originalFunctions[name]) {
-      this.originalFunctions[name] = func;
-    }
-
-    // Auto-bind function to this ToolsService instance
-    const boundFunc = func.bind(this);
-
-    // Check for overrides first
-    const override = this.findMatchingOverride(name);
-    if (override) {
-      this.functions[name] = async (...args: any[]) => {
-        const tool = this.getTool(name);
-        return await override.override(args, tool);
-      };
-      return;
-    }
-
-    // Check for wrappers
-    const wrappers = this.findMatchingWrappers(name);
-    if (wrappers.length > 0) {
-      let wrappedFunction = boundFunc;
-
-      // Apply wrappers in priority order
-      for (const wrapperReg of wrappers) {
-        const currentFunction = wrappedFunction;
-        wrappedFunction = async (...args: any[]) => {
-          const tool = this.getTool(name);
-          return await wrapperReg.wrapper(currentFunction, args, tool);
-        };
-      }
-
-      this.functions[name] = wrappedFunction;
-      return;
+      this.originalFunctions[name] = func.bind(this);
     }
 
-    // No overrides or wrappers, use bound function
-    this.functions[name] = boundFunc;
+    // Set the function (bound) and apply any overrides/wrappers
+    this.functions[name] = func.bind(this);
+    this.applyOverridesAndWrappers(name);
   }
 
   setFunctions(names: string[], funcs: ((...args: any) => any)[]) {
@@ -167,12 +148,20 @@ export class ToolsService {
 
   async callTool(toolCall: ToolCall, enabledTools = this.getToolNames()) {
     const functionName = toolCall.function.name;
-    const functionArgs =
-      typeof toolCall.function.arguments === "string"
-        ? JSON.parse(restoreEscapedNewLines(toolCall.function.arguments))
-        : toolCall.function.arguments;
+    let functionArgs: any;
 
     try {
+      try {
+        functionArgs =
+          typeof toolCall.function.arguments === "string"
+            ? JSON.parse(restoreEscapedNewLines(toolCall.function.arguments))
+            : toolCall.function.arguments;
+      } catch (error) {
+        throw new Error(
+          `Invalid JSON in tool call arguments: ${error.message}`
+        );
+      }
+
       // Check if tool is enabled
       if (!enabledTools.includes(functionName)) {
         const options = enabledTools.join(", ");
@@ -204,20 +193,22 @@ export class ToolsService {
         ? Object.keys(properties).map((p) => functionArgs[p])
         : functionArgs;
 
-      console.log(
-        `Calling function ${functionName} with args:`,
-        JSON.stringify(fnArgs, null, 2)
-      );
-
       // Execute the function
-      const functionResponse = await Promise.resolve(
-        isPositional ? functionToCall(...fnArgs) : functionToCall(fnArgs)
-      ).catch((e) => {
+      const rawResponse = isPositional
+        ? functionToCall.call(this, ...fnArgs)
+        : functionToCall.call(this, fnArgs);
+      const functionResponse = await Promise.resolve(rawResponse).catch((e) => {
         throw new Error("ERROR: " + e.message);
       });
 
       // Helper function to convert objects to JSON
       const toJsonIfObject = (arg: any) => {
+        if (arg === null) {
+          return "null";
+        }
+        if (arg === undefined) {
+          return "undefined";
+        }
         if (typeof arg === "object") {
           return JSON.stringify(arg, null, 2);
         }
@@ -228,14 +219,18 @@ export class ToolsService {
 
       // Handle special case for parallel tool use
       if (functionName === "multi_tool_use.parallel") {
-        const args = fnArgs[0] as {
+        // Extract tool_calls array from arguments
+        const toolCallsArg = Array.isArray(fnArgs) ? fnArgs : [fnArgs];
+        const toolCalls = Array.isArray(toolCallsArg) ? toolCallsArg : [];
+
+        const calls = toolCalls as {
           recipient_name: string;
           parameters: any;
         }[];
 
-        toolMessages = args.map((call, index) => {
+        toolMessages = calls.map((call, index) => {
           return {
-            tool_call_id: toolCall.id + "_" + index,
+            tool_call_id: `call_parallel_${index}`,
             role: "tool",
             name: call.recipient_name.split(".").pop(),
             content: toJsonIfObject(functionResponse[index]) || "Done",
@@ -257,7 +252,7 @@ export class ToolsService {
         toolCallId: toolCall.id,
         functionName,
         functionArgs,
-        functionResp: functionResponse,
+        functionResp: functionResponse || "Done",
       };
     } catch (error) {
       console.log(error.message);
@@ -288,6 +283,13 @@ export class ToolsService {
   ): void {
     this.overrides.push({ pattern, override, priority });
     this.overrides.sort((a, b) => b.priority - a.priority);
+
+    // Re-apply overrides to existing functions
+    for (const toolName of this.getToolNames()) {
+      if (this.functions[toolName]) {
+        this.applyOverridesAndWrappers(toolName);
+      }
+    }
   }
 
   registerWrapper(
@@ -296,27 +298,97 @@ export class ToolsService {
     priority: number = 0
   ): void {
     this.wrappers.push({ pattern, wrapper, priority });
+
+    // Sort wrappers by priority first
     this.wrappers.sort((a, b) => b.priority - a.priority);
+
+    // Re-apply wrappers to existing functions
+    for (const toolName of this.getToolNames()) {
+      if (this.functions[toolName]) {
+        this.applyOverridesAndWrappers(toolName);
+      }
+    }
   }
 
   removeOverride(pattern: string | RegExp): void {
     this.overrides = this.overrides.filter((reg) => reg.pattern !== pattern);
+    // Re-apply functions after removing override
+    for (const toolName of this.getToolNames()) {
+      if (this.originalFunctions[toolName]) {
+        this.setFunction(toolName, this.originalFunctions[toolName]);
+      }
+    }
   }
 
   removeWrapper(pattern: string | RegExp): void {
     this.wrappers = this.wrappers.filter((reg) => reg.pattern !== pattern);
+    // Re-apply functions after removing wrapper
+    for (const toolName of this.getToolNames()) {
+      if (this.originalFunctions[toolName]) {
+        this.setFunction(toolName, this.originalFunctions[toolName]);
+      }
+    }
+  }
+
+  private applyOverridesAndWrappers(name: string): void {
+    if (!this.originalFunctions[name]) {
+      // Store original function if not already stored
+      this.originalFunctions[name] = this.functions[name];
+    }
+
+    const originalFunc = this.originalFunctions[name];
+
+    // Check for overrides first
+    const matchingOverride = this.findMatchingOverride(name);
+    if (matchingOverride) {
+      // Create a wrapper function that calls the override with correct arguments
+      this.functions[name] = ((...args: any[]) => {
+        // Call the override function with originalArgs array and tool definition
+        const toolDefinition = this.getTool(name);
+        // Override functions expect (originalArgs: any[], originalTool: Tool)
+        return matchingOverride.override.call(this, args, toolDefinition);
+      }).bind(this);
+      return;
+    }
+
+    // Check for wrappers
+    const wrappers = this.findMatchingWrappers(name);
+    if (wrappers.length > 0) {
+      let wrappedFunction = originalFunc;
+
+      // Apply wrappers in priority order
+      for (const wrapperReg of wrappers) {
+        const innerFunc = wrappedFunction;
+        wrappedFunction = ((args: any) => {
+          const toolDefinition = this.getTool(name);
+          return wrapperReg.wrapper(innerFunc, args, toolDefinition);
+        }).bind(this);
+      }
+
+      this.functions[name] = wrappedFunction.bind(this);
+    } else {
+      // No wrappers, use current function (might be override or original)
+      this.functions[name] = originalFunc;
+    }
   }
 
   private findMatchingOverride(
     toolName: string
   ): ToolOverrideRegistration | null {
+    let bestMatch: ToolOverrideRegistration | null = null;
+    let highestPriority = -1;
+
     for (const registration of this.overrides) {
       const matcher = createPatternMatcher(registration.pattern);
       if (matcher.matches(toolName)) {
-        return registration;
+        if (registration.priority > highestPriority) {
+          highestPriority = registration.priority;
+          bestMatch = registration;
+        }
       }
     }
-    return null;
+
+    return bestMatch;
   }
 
   private findMatchingWrappers(toolName: string): ToolWrapperRegistration[] {

package/src/services/index.ts

@@ -1,6 +1,5 @@
 import { DownloaderService } from "../plugins/downloader/downloader";
-import { Clients } from "../clients";
-import { Plugins } from "../plugins/plugins";
+import { AIClient, Clients } from "../clients";
 import { AgentService } from "./AgentService";
 import { EventService } from "./EventService";
 import { FlagsService } from "./flags";
@@ -9,6 +8,7 @@ import { KnowhowSimpleClient } from "./KnowhowClient";
 import { McpService } from "./Mcp";
 import { S3Service } from "./S3";
 import { ToolsService } from "./Tools";
+import { PluginService } from "../plugins/plugins";
 
 export * from "./AgentService";
 export * from "./EventService";
@@ -19,7 +19,6 @@ export * from "./Tools";
 export * as MCP from "./Mcp";
 export * from "./EmbeddingService";
 export { Clients } from "../clients";
-export { Plugins };
 
 let Singletons = {} as {
   Tools: ToolsService;
@@ -30,8 +29,8 @@ let Singletons = {} as {
   Mcp: McpService;
   AwsS3: S3Service;
   knowhowApiClient: KnowhowSimpleClient;
-  Plugins: typeof Plugins;
-  Clients: typeof Clients;
+  Plugins: PluginService;
+  Clients: AIClient;
   Downloader: DownloaderService;
 };
 
@@ -41,19 +40,25 @@ export const services = (): typeof Singletons => {
     const Events = new EventService();
     const Agents = new AgentService(Tools, Events);
     const Downloader = new DownloaderService(Clients);
-    Singletons = {
-      Tools,
+    const Plugins = new PluginService({
+      Agents,
       Events,
+      Tools,
+      Clients,
+    });
+
+    Singletons = {
       Agents,
+      AwsS3: new S3Service(),
+      Clients,
       Downloader,
-
+      Events,
       Flags: new FlagsService(),
       GitHub: new GitHubService(),
       Mcp: new McpService(),
-      AwsS3: new S3Service(),
-      knowhowApiClient: new KnowhowSimpleClient(process.env.KNOWHOW_API_URL),
       Plugins,
-      Clients,
+      Tools,
+      knowhowApiClient: new KnowhowSimpleClient(process.env.KNOWHOW_API_URL),
     };
 
     Singletons.Tools.setContext({

package/src/services/types.ts

@@ -34,9 +34,9 @@ export class StringPatternMatcher implements PatternMatcher {
   matches(toolName: string): boolean {
     // Convert glob pattern to regex
     const regexPattern = this.pattern
-      .replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
-      .replace(/\\\*/g, ".*") // Convert * to .*
-      .replace(/\\\?/g, "."); // Convert ? to .
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except * and ?
+      .replace(/\*/g, ".*") // Convert * to .*
+      .replace(/\?/g, "."); // Convert ? to .
 
     const regex = new RegExp(`^${regexPattern}$`);
     return regex.test(toolName);

package/src/types.ts

@@ -57,7 +57,7 @@ export type Config = {
     enabled?: boolean;
     installPath?: string;
     port?: number;
-    logLevel?: 'debug' | 'info' | 'warning' | 'error';
+    logLevel?: "debug" | "info" | "warning" | "error";
     completionTimeout?: number;
   };
 
@@ -82,6 +82,7 @@ export type McpConfig = {
   env?: { [key: string]: string };
   params?: Partial<{ socket: WebSocket }>;
   authorization_token?: string;
+  authorization_token_file?: string;
 };
 
 export type ModelProvider = {
@@ -122,6 +123,7 @@ export interface IDatasource {
 
 export type Language = {
   [term: string]: {
+    events: string[];
     sources: IDatasource[];
     context?: string;
   };
@@ -137,6 +139,9 @@ export type ChatInteraction = {
 export const Models = {
   anthropic: {
     Opus4: "claude-opus-4-20250514",
+    Opus4_1: "claude-opus-4-1-20250805",
+    Sonnet4_5: "claude-sonnet-4-5-20250929",
+    Haiku4_5: "claude-haiku-4-5-20251001",
     Sonnet4: "claude-sonnet-4-20250514",
     Sonnet3_7: "claude-3-7-sonnet-20250219",
     Sonnet3_5: "claude-3-5-sonnet-20241022",
@@ -145,6 +150,7 @@ export const Models = {
     Haiku3: "claude-3-haiku-20240307",
   },
   xai: {
+    GrokCodeFast: "grok-code-fast-1",
     Grok4: "grok-4-0709",
     Grok3Beta: "grok-3-beta",
     Grok3MiniBeta: "grok-3-mini-beta",
@@ -248,4 +254,3 @@ export const GoogleImageModels = [
 export const GoogleVideoModels = [Models.google.Veo_2];
 
 export const GoogleEmbeddingModels = [EmbeddingModels.google.Gemini_Embedding];
-

package/src/worker.ts

@@ -68,12 +68,25 @@ export async function worker() {
     });
 
     mcpServer.runWsServer(ws);
+
+    return { ws, mcpServer };
   }
 
   while (true) {
+    let connection: { ws: WebSocket; mcpServer: McpServerService } | null =
+      null;
+
     if (!connected) {
       console.log("Attempting to connect...");
-      connectWebSocket();
+      connection = await connectWebSocket();
+    }
+    if (connection && connected) {
+      try {
+        await connection.ws.ping();
+      } catch (error) {
+        console.error("WebSocket ping failed:", error);
+        connected = false;
+      }
     }
     await wait(5000);
   }