@tyvm/knowhow 0.0.20 → 0.0.22

package/src/agents/tools/executeScript/examples/test-runner.ts

@@ -0,0 +1,204 @@
+#!/usr/bin/env ts-node
+/**
+ * Test runner for the executeScript tool
+ * Usage: npx ts-node src/agents/tools/executeScript/examples/test-runner.ts
+ */
+
+import { executeScript } from "../../executeScript";
+import { Tools } from "../../../../services";
+import { Clients } from "../../../../clients";
+import { includedTools } from "../../../tools/list";
+import * as allTools from "../../../tools";
+
+// Sample script to test with
+const testScript = `
+// Test script that demonstrates various executeScript capabilities
+console.log("Starting test script execution...");
+
+async function main() {
+  // Test 1: Simple console output
+  console.log("Test 1: Basic logging works");
+
+  // Test 2: Call a tool (file search)
+  try {
+    console.log("Test 2: Calling fileSearch tool...");
+    const searchResult = await callTool("fileSearch", {
+      searchTerm: "package.json"
+    });
+    console.log("File search result:", searchResult);
+  } catch (error) {
+    console.error("Tool call failed:", error.message);
+  }
+
+  // Test 3: Call another tool (text search)
+  try {
+    console.log("Test 3: Calling textSearch tool...");
+    const textResult = await callTool("textSearch", {
+      searchTerm: "executeScript"
+    });
+    console.log("Text search found", textResult?.length || 0, "matches");
+  } catch (error) {
+    console.error("Text search failed:", error.message);
+  }
+
+  // Test 4: Make an LLM call
+  try {
+    console.log("Test 4: Making LLM call...");
+    const llmResponse = await llm([
+      {
+        role: "system",
+        content: "You are a helpful assistant. Respond with exactly one sentence."
+      },
+      {
+        role: "user",
+        content: "What is 2+2? Just give the answer briefly."
+      }
+    ], {
+      model: "gpt-4o-mini",
+      max_tokens: 50
+    });
+
+    console.log("LLM Response:", llmResponse.choices[0].message.content);
+  } catch (error) {
+    console.error("LLM call failed:", error.message);
+  }
+
+  // Test 5: Create an artifact
+  try {
+    console.log("Test 5: Creating artifact...");
+    createArtifact("test-results.md", \`# Test Results
+
+Script executed successfully at: \${new Date().toISOString()}
+
+This is a test artifact created by the executeScript tool.
+
+## Test Summary
+- Console logging: ✓
+- Tool calls: ✓
+- LLM calls: ✓
+- Artifact creation: ✓
+\`, "markdown");
+    console.log("Artifact created successfully");
+  } catch (error) {
+    console.error("Artifact creation failed:", error.message);
+  }
+
+  // Return final result
+  return {
+    success: true,
+    message: "All tests completed successfully",
+    timestamp: new Date().toISOString(),
+    testsRun: 5
+  };
+}
+
+// Execute the main function
+await main().then(result => {
+  console.log("=== SCRIPT COMPLETED ===");
+  console.log("Final result:", JSON.stringify(result, null, 2));
+}).catch(error => {
+  console.error("=== SCRIPT FAILED ===");
+  console.error("Error:", error);
+  throw error;
+});
+`;
+
+async function runTest() {
+  console.log("🚀 Starting executeScript test...\n");
+
+  try {
+    Tools.defineTools(includedTools, allTools);
+
+    const context = {
+      tools: Tools,
+      clients: Clients,
+    };
+
+    console.log("📋 Test Parameters:");
+    console.log("- Max Tool Calls: 10");
+    console.log("- Max Tokens: 1000");
+    console.log("- Max Execution Time: 60s");
+    console.log("- Max Cost: $0.50\n");
+
+    const startTime = Date.now();
+
+    // Execute the test script
+    const result = await executeScript(
+      {
+        script: testScript,
+        maxToolCalls: 10,
+        maxTokens: 1000,
+        maxExecutionTimeMs: 60000,
+        maxCostUsd: 0.5,
+      },
+      context
+    );
+
+    const executionTime = Date.now() - startTime;
+
+    console.log("\n" + "=".repeat(60));
+    console.log("🎯 TEST RESULTS");
+    console.log("=".repeat(60));
+    console.log(`⏱️  Execution Time: ${executionTime}ms`);
+    console.log(`✅ Success: ${result.success}`);
+
+    if (result.success) {
+      console.log(`📊 Result:`, result.result);
+      console.log(`🔧 Tool Calls Made: ${result.quotaUsage.toolCalls}`);
+      console.log(`🎯 Tokens Used: ${result.quotaUsage.tokens}`);
+      console.log(`💰 Cost: $${result.quotaUsage.costUsd.toFixed(4)}`);
+
+      if (result.artifacts.length > 0) {
+        console.log(`📁 Artifacts Created: ${result.artifacts.length}`);
+        result.artifacts.forEach((artifact) => {
+          console.log(
+            `   - ${artifact.name} (${artifact.type}, ${artifact.contentLength} bytes)`
+          );
+        });
+      }
+
+      if (result.consoleOutput.length > 0) {
+        console.log(
+          `\n📝 Console Output (${result.consoleOutput.length} entries):`
+        );
+        result.consoleOutput.forEach((entry) => {
+          console.log(`   ${entry}`);
+        });
+      }
+
+      if (result.violations.length > 0) {
+        console.log(`\n⚠️  Policy Violations: ${result.violations.length}`);
+        result.violations.forEach((violation) => {
+          console.log(`   - ${JSON.stringify(violation)}`);
+        });
+      }
+    } else {
+      console.log(`❌ Error: ${result.error}`);
+
+      if (result.consoleOutput.length > 0) {
+        console.log(`\n📝 Console Output Before Failure:`);
+        result.consoleOutput.forEach((entry) => {
+          console.log(`   ${entry}`);
+        });
+      }
+    }
+
+    console.log("\n" + "=".repeat(60));
+    console.log(result.success ? "🎉 TEST PASSED!" : "💥 TEST FAILED!");
+    console.log("=".repeat(60));
+  } catch (error) {
+    console.error("\n💥 TEST RUNNER ERROR:");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Run the test if this file is executed directly
+if (require.main === module) {
+  runTest().catch((error) => {
+    console.error("Unhandled error:", error);
+    process.exit(1);
+  });
+}
+
+export { runTest, testScript };

package/src/agents/tools/executeScript/index.ts

@@ -0,0 +1,74 @@
+import { ScriptExecutor } from "../../../services/script-execution/ScriptExecutor";
+import { Tools } from "../../../services";
+import { Clients } from "../../../clients";
+import {
+  ExecutionRequest,
+  ExecutionResult,
+} from "../../../services/script-execution/types";
+
+
+export const executeScript = async (
+  { script, maxToolCalls, maxTokens, maxExecutionTimeMs, maxCostUsd },
+  context
+) => {
+  try {
+    // Create script executor with access to tools and clients
+    const executor = new ScriptExecutor(Tools, Clients);
+
+    // Execute the script
+    const result = await executor.execute({
+      script,
+      quotas: {
+        maxToolCalls: maxToolCalls || 50,
+        maxTokens: maxTokens || 10000,
+        maxExecutionTimeMs: maxExecutionTimeMs || 30000,
+        maxCostUsd: maxCostUsd || 1.0,
+        maxMemoryMb: 100,
+      },
+    });
+
+    // If there were policy violations, include them in the response
+    const violations = result.trace.events
+      .filter((e) => e.type.includes("violation") || e.type.includes("error"))
+      .map((e) => e.data);
+
+    // Format the response
+    return {
+      success: result.success,
+      result: result.result,
+      error: result.error,
+      artifacts: result.artifacts.map((a) => ({
+        id: a.id,
+        name: a.name,
+        type: a.type,
+        contentLength: a.content.length,
+        createdAt: a.createdAt,
+      })),
+      consoleOutput: result.consoleOutput,
+      metrics: result.trace.metrics,
+      violations,
+      executionTimeMs: result.trace.endTime - result.trace.startTime,
+      quotaUsage: {
+        toolCalls: result.trace.metrics.toolCallCount,
+        tokens: result.trace.metrics.tokenUsage.total,
+        costUsd: result.trace.metrics.costUsd,
+      },
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      result: null,
+      artifacts: [],
+      consoleOutput: [],
+      metrics: null,
+      violations: [],
+      executionTimeMs: 0,
+      quotaUsage: {
+        toolCalls: 0,
+        tokens: 0,
+        costUsd: 0,
+      },
+    };
+  }
+};

package/src/agents/tools/index.ts

@@ -23,3 +23,4 @@ export * from "./aiClient";
 export * from "./googleSearch";
 export * from "./loadWebpage";
 export * from "./stringReplace";
+export * from "./executeScript";

package/src/agents/tools/list.ts

@@ -7,6 +7,7 @@ import * as github from "./github/definitions";
 import * as asana from "./asana/definitions";
 import * as language from "./language/definitions";
 import { googleSearchDefinition } from "./googleSearch";
+import { executeScriptDefinition } from "./executeScript/definition";
 
 export const includedTools = [
   {
@@ -552,7 +553,7 @@ export const includedTools = [
       },
     },
   },
-
+  executeScriptDefinition,
   googleSearchDefinition,
   ...asana.definitions,
   ...github.definitions,

package/src/cli.ts

@@ -11,7 +11,7 @@ import { Vimmer } from "./agents/vim/vim";
 import { Developer } from "./agents/developer/developer";
 import { Tools } from "./services";
 import { includedTools } from "./agents/tools/list";
-import * as allTools from "./agents/tools/index";
+import * as allTools from "./agents/tools";
 import { Mcp } from "./services/Mcp";
 import { login } from "./login";
 import { worker } from "./worker";
@@ -24,12 +24,8 @@ async function main() {
   Agents.registerAgent(Patcher);
   Agents.registerAgent(Developer);
   Agents.loadAgentsFromConfig();
-  Tools.addTools(includedTools);
 
-  const toolFunctions = Object.entries(allTools)
-    .filter(([_, value]) => typeof value === 'function')
-    .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
-  Tools.addFunctions(toolFunctions);
+  Tools.defineTools(includedTools, allTools);
 
   await Mcp.connectToConfigured(Tools);
   await Clients.registerConfiguredModels();

package/src/clients/index.ts

@@ -153,13 +153,24 @@ export class AIClient {
     );
   }
 
-  private providerHasModel(provider: string, model: string): boolean {
+  providerHasModel(provider: string, model: string): boolean {
     const models = this.clientModels[provider];
     if (!models) return false;
     return models.includes(model);
   }
 
-  private detectProviderModel(provider: string, model?: string) {
+  findModel(modelPrefix: string) {
+    for (const provider of Object.keys(this.clientModels)) {
+      const models = this.clientModels[provider];
+      const foundModel = models.find((m) => m.startsWith(modelPrefix));
+      if (foundModel) {
+        return { provider, model: foundModel };
+      }
+    }
+    return undefined;
+  }
+
+  detectProviderModel(provider: string, model?: string) {
     if (this.providerHasModel(provider, model)) {
       return { provider, model };
     }
@@ -170,18 +181,21 @@ export class AIClient {
       const inferredProvider = split[0];
       const inferredModel = split.slice(1).join("/");
 
+      // Exact match
       if (this.providerHasModel(inferredProvider, inferredModel)) {
         return { provider: inferredProvider, model: inferredModel };
       }
-    }
 
-    const providers = Object.keys(this.clientModels);
-    const foundProvider = providers.find((p) =>
-      this.providerHasModel(p, model)
-    );
+      // Starts with match
+      const foundBySplit = this.findModel(inferredModel);
+      if (foundBySplit) {
+        return foundBySplit;
+      }
+    }
 
-    if (foundProvider) {
-      return { provider: foundProvider, model };
+    const foundByModel = this.findModel(model);
+    if (foundByModel) {
+      return foundByModel;
     }
 
     return { provider, model };

package/src/services/Tools.ts

@@ -1,7 +1,14 @@
 import { ChatCompletionTool } from "openai/resources/chat";
+import { replaceEscapedNewLines, restoreEscapedNewLines } from "../utils";
 import { includedTools } from "../agents/tools/list";
-import { Tool } from "../clients/types";
-import { ToolOverrideRegistration, ToolWrapperRegistration, ToolOverrideFunction, ToolWrapper, createPatternMatcher } from "./types";
+import { Tool, ToolCall } from "../clients/types";
+import {
+  ToolOverrideRegistration,
+  ToolWrapperRegistration,
+  ToolOverrideFunction,
+  ToolWrapper,
+  createPatternMatcher,
+} from "./types";
 
 export class ToolsService {
   tools = [] as Tool[];
@@ -61,7 +68,7 @@ export class ToolsService {
     const wrappers = this.findMatchingWrappers(name);
     if (wrappers.length > 0) {
       let wrappedFunction = func;
-      
+
       // Apply wrappers in priority order
       for (const wrapperReg of wrappers) {
         const currentFunction = wrappedFunction;
@@ -70,7 +77,7 @@ export class ToolsService {
           return await wrapperReg.wrapper(currentFunction, args, tool);
         };
       }
-      
+
       this.functions[name] = wrappedFunction;
       return;
     }
@@ -90,15 +97,147 @@ export class ToolsService {
   }
 
   addTools(tools: Tool[]) {
-    this.tools.push(...tools);
+    // Prevent duplicate tool names
+    const existingTools = this.getToolNames();
+    const filteredTools = tools.filter(
+      (tool) => !existingTools.includes(tool.function.name)
+    );
+
+    this.tools.push(...filteredTools);
   }
 
   addFunctions(fns: { [fnName: string]: (...args: any) => any }) {
     for (const fnName of Object.keys(fns)) {
+      if (typeof fns[fnName] !== "function") {
+        // Skip non-function entries
+        continue;
+      }
       this.setFunction(fnName, fns[fnName]);
     }
   }
 
+  defineTools(
+    tools: Tool[],
+    functions: { [fnName: string]: ((...args: any) => any) | any }
+  ) {
+    this.addTools(tools);
+    this.addFunctions(functions);
+  }
+
+  async callTool(toolCall: ToolCall, enabledTools = this.getToolNames()) {
+    const functionName = toolCall.function.name;
+    const functionArgs = JSON.parse(
+      restoreEscapedNewLines(toolCall.function.arguments)
+    );
+
+    try {
+      // Check if tool is enabled
+      if (!enabledTools.includes(functionName)) {
+        const options = enabledTools.join(", ");
+        throw new Error(
+          `Function ${functionName} not enabled, options are ${options}`
+        );
+      }
+
+      // Check if tool definition exists
+      const toolDefinition = this.getTool(functionName);
+      if (!toolDefinition) {
+        throw new Error(`Tool ${functionName} not found`);
+      }
+
+      // Check if function implementation exists
+      const functionToCall = this.getFunction(functionName);
+      if (!functionToCall) {
+        const options = enabledTools.join(", ");
+        throw new Error(
+          `Function ${functionName} not found, options are ${options}`
+        );
+      }
+
+      // Prepare function arguments
+      const properties = toolDefinition?.function?.parameters?.properties || {};
+      const isPositional =
+        toolDefinition?.function?.parameters?.positional || false;
+      const fnArgs = isPositional
+        ? 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) => {
+        throw new Error("ERROR: " + e.message);
+      });
+
+      // Helper function to convert objects to JSON
+      const toJsonIfObject = (arg: any) => {
+        if (typeof arg === "object") {
+          return JSON.stringify(arg, null, 2);
+        }
+        return arg;
+      };
+
+      let toolMessages = [];
+
+      // Handle special case for parallel tool use
+      if (functionName === "multi_tool_use.parallel") {
+        const args = fnArgs[0] as {
+          recipient_name: string;
+          parameters: any;
+        }[];
+
+        toolMessages = args.map((call, index) => {
+          return {
+            tool_call_id: toolCall.id + "_" + index,
+            role: "tool",
+            name: call.recipient_name.split(".").pop(),
+            content: toJsonIfObject(functionResponse[index]) || "Done",
+          };
+        });
+      } else {
+        toolMessages = [
+          {
+            tool_call_id: toolCall.id,
+            role: "tool",
+            name: functionName,
+            content: toJsonIfObject(functionResponse) || "Done",
+          },
+        ];
+      }
+
+      return {
+        toolMessages,
+        toolCallId: toolCall.id,
+        functionName,
+        functionArgs,
+        functionResp: functionResponse,
+      };
+    } catch (error) {
+      console.log(error.message);
+      const toolMessages = [
+        {
+          tool_call_id: toolCall.id,
+          role: "tool",
+          name: "error",
+          content: error.message,
+        },
+      ];
+
+      return {
+        toolMessages,
+        toolCallId: toolCall.id,
+        functionName,
+        functionArgs,
+        functionResp: undefined,
+      };
+    }
+  }
+
   // Tool Override Methods
   registerOverride(
     pattern: string | RegExp,
@@ -119,14 +258,16 @@ export class ToolsService {
   }
 
   removeOverride(pattern: string | RegExp): void {
-    this.overrides = this.overrides.filter(reg => reg.pattern !== pattern);
+    this.overrides = this.overrides.filter((reg) => reg.pattern !== pattern);
   }
 
   removeWrapper(pattern: string | RegExp): void {
-    this.wrappers = this.wrappers.filter(reg => reg.pattern !== pattern);
+    this.wrappers = this.wrappers.filter((reg) => reg.pattern !== pattern);
   }
 
-  private findMatchingOverride(toolName: string): ToolOverrideRegistration | null {
+  private findMatchingOverride(
+    toolName: string
+  ): ToolOverrideRegistration | null {
     for (const registration of this.overrides) {
       const matcher = createPatternMatcher(registration.pattern);
       if (matcher.matches(toolName)) {
@@ -161,4 +302,4 @@ export class ToolsService {
   }
 }
 
-export const Tools = new ToolsService();
+export const Tools = new ToolsService();