@tyvm/knowhow 0.0.47 → 0.0.49

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);
   }

package/test-comprehensive.ts

@@ -0,0 +1,31 @@
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+class UserService {
+  private users: User[] = [];
+
+  addUser(user: User): void {
+    this.users.push(user);
+  }
+
+  findUser(id: number): User | undefined {
+    return this.users.find(u => u.id === id);
+  }
+}
+
+const service = new UserService();
+service.addUser({
+  id: 1,
+  name: "John",
+  email: "john@example.com"
+});
+
+// Test completion on service methods
+const result = service.fi; // Should complete to findUser
+
+// Test completion on User interface properties
+const user: User = { id: 1, name: "Test", email: "test@test.com" };
+console.log(user.na); // Should complete to name