@tyvm/knowhow 0.0.108-dev.c47492f → 0.0.108-dev.d003f8f

package/src/agents/tools/executeScript/examples/dependency-injection-validation.ts

@@ -1,272 +0,0 @@
-#!/usr/bin/env ts-node
-/**
- * Comprehensive test for Tools Dependency Injection System
- *
- * This test validates:
- * 1. Context injection is working properly
- * 2. Tools can access services via `this.getContext()`
- * 3. Agent isolation is functioning (each agent has independent context)
- * 4. No singleton usage in tool implementations
- * 5. Backward compatibility is maintained
- *
- * Usage: npx ts-node src/agents/tools/executeScript/examples/dependency-injection-validation.ts
- */
-
-import { ToolsService } from "../../../../services/Tools";
-import { Clients } from "../../../../clients";
-import { EventService, services } from "../../../../services/";
-import { BaseAgent } from "../../../base/base";
-import { Message } from "../../../../clients/types";
-import { includedTools } from "../../list";
-import { executeScript } from "../";
-import { executeScriptDefinition } from "../definition";
-
-// Test Agent that extends BaseAgent to test agent isolation
-class TestAgent1 extends BaseAgent {
-  name = "TestAgent1";
-  description = "Test agent for dependency injection validation";
-
-  async getInitialMessages(userInput: string): Promise<Message[]> {
-    return [
-      { role: "system", content: this.description },
-      { role: "user", content: userInput },
-    ];
-  }
-
-  // Expose toolsService for testing
-  public getToolsServiceForTest() {
-    return this.tools;
-  }
-}
-
-class TestAgent2 extends BaseAgent {
-  name = "TestAgent2";
-  description = "Another test agent for dependency injection validation";
-
-  async getInitialMessages(userInput: string): Promise<Message[]> {
-    return [
-      { role: "system", content: this.description },
-      { role: "user", content: userInput },
-    ];
-  }
-
-  // Expose toolsService for testing
-  public getToolsServiceForTest() {
-    return this.tools;
-  }
-}
-
-// Test tool function that uses context injection
-function testToolWithContext(this: ToolsService, params: { message: string }) {
-  const context = this.getContext();
-
-  console.log("✅ Tool called with context:");
-  console.log("- AgentService available:", !!context.Agents);
-  console.log("- EventService available:", !!context.Events);
-  console.log("- Clients available:", !!context.Clients);
-  console.log("- ToolsService self-reference available:", !!context.Tools);
-  console.log("- Test message:", params.message);
-
-  return {
-    success: true,
-    contextValidated: true,
-    hasAgentService: !!context.Agents,
-    hasEventService: !!context.Events,
-    hasClients: !!context.Clients,
-    hasToolsService: !!context.Tools,
-    testMessage: params.message,
-  };
-}
-
-async function runValidationTests() {
-  console.log("🧪 Starting Tools Dependency Injection Validation Tests\n");
-
-  // Test 1: Create independent agents with their own ToolsService instances
-  console.log("📍 Test 1: Agent Isolation");
-  const agent1 = new TestAgent1({
-    Events: new EventService(),
-    Tools: new ToolsService({ Clients }),
-  });
-  const agent2 = new TestAgent2({
-    Events: new EventService(),
-    Tools: new ToolsService(),
-  });
-
-  const toolsService1 = agent1.getToolsServiceForTest();
-  const toolsService2 = agent2.getToolsServiceForTest();
-
-  // Verify agents have different ToolsService instances
-  console.log(
-    "✅ Agent1 and Agent2 have different ToolsService instances:",
-    toolsService1 !== toolsService2
-  );
-
-  // Test 2: Context validation for each agent
-  console.log("\n📍 Test 2: Context Injection Validation");
-
-  const context1 = toolsService1.getContext();
-  const context2 = toolsService2.getContext();
-
-  console.log("✅ Agent1 context has required services:", {
-    agentService: !!context1.Agents,
-    eventService: !!context1.Events,
-    clients: !!context1.Clients,
-    toolsService: !!context1.Tools,
-  });
-
-  console.log("✅ Agent2 context has required services:", {
-    agentService: !!context2.Agents,
-    eventService: !!context2.Events,
-    clients: !!context2.Clients,
-    toolsService: !!context2.Tools,
-  });
-
-  // Test 3: Register a test tool and verify it can access context
-  console.log("\n📍 Test 3: Tool Context Access");
-
-  // Register the test tool on agent1's ToolsService
-  toolsService1.addTool({
-    type: "function",
-    function: {
-      name: "testToolWithContext",
-      description: "Test tool for context validation",
-      parameters: {
-        type: "object",
-        properties: {
-          message: { type: "string", description: "Test message" },
-        },
-        required: ["message"],
-      },
-    },
-  });
-
-  toolsService1.setFunction("testToolWithContext", testToolWithContext);
-  try {
-    const result = await toolsService1.callTool({
-      id: "test-call",
-      type: "function",
-      function: {
-        name: "testToolWithContext",
-        arguments: JSON.stringify({ message: "Hello from Agent1!" }),
-      },
-    });
-    console.log(
-      "✅ Tool executed successfully with context access:",
-      result.functionResp?.success
-    );
-  } catch (error) {
-    console.error("❌ Tool execution failed:", error);
-  }
-
-  // Test 4: Verify agent isolation - agent2 should not have agent1's tool
-  console.log("\n📍 Test 4: Tool Isolation Between Agents");
-
-  const agent1Tools = toolsService1.getTools().map((t) => t.function.name);
-  const agent2Tools = toolsService2.getTools().map((t) => t.function.name);
-
-  console.log("Agent1 tools:", agent1Tools.length);
-  console.log("Agent2 tools:", agent2Tools.length);
-  console.log(
-    "✅ Agent2 does not have agent1's custom tool:",
-    !agent2Tools.includes("testToolWithContext")
-  );
-
-  // Test 5: Add different tool to agent2 to verify independence
-  function agent2SpecificTool(this: ToolsService, params: { data: string }) {
-    const context = this.getContext();
-    return {
-      agent: "Agent2",
-      data: params.data,
-      contextAvailable: !!context,
-    };
-  }
-
-  toolsService2.addTool({
-    type: "function",
-    function: {
-      name: "agent2SpecificTool",
-      description: "Tool specific to Agent2",
-      parameters: {
-        type: "object",
-        properties: {
-          data: { type: "string", description: "Test data" },
-        },
-        required: ["data"],
-      },
-    },
-  });
-  toolsService2.setFunction("agent2SpecificTool", agent2SpecificTool);
-
-  const agent1ToolsAfter = toolsService1.getTools().map((t) => t.function.name);
-  const agent2ToolsAfter = toolsService2.getTools().map((t) => t.function.name);
-
-  console.log(
-    "✅ Agent1 does not have agent2's tool:",
-    !agent1ToolsAfter.includes("agent2SpecificTool")
-  );
-  console.log(
-    "✅ Agent2 has its specific tool:",
-    agent2ToolsAfter.includes("agent2SpecificTool")
-  );
-
-  // Test 6: Verify executeScript tool is using context injection
-  console.log("\n📍 Test 6: executeScript Context Integration");
-
-  // Test that executeScript uses the bound context instead of singletons
-  const executeScriptTest = `
-    async function main() {
-      return callTool("testToolWithContext", {message: "Hello from executeScript!"});
-    }
-    return main()
-  `;
-
-  toolsService1.defineTools([executeScriptDefinition], { executeScript });
-
-  try {
-    const executeResult = await toolsService1.callTool({
-      id: "execute-test",
-      type: "function",
-      function: {
-        name: "executeScript",
-        arguments: JSON.stringify({ script: executeScriptTest }),
-      },
-    });
-    console.log(
-      "✅ executeScript using dependency injection:",
-      executeResult.functionResp
-    );
-  } catch (error) {
-    console.error("❌ executeScript test failed:", error);
-  }
-
-  console.log("\n🎉 All Tests Completed!");
-  console.log("\n📊 Test Summary:");
-  console.log(
-    "✅ Agent isolation working - each agent has independent ToolsService"
-  );
-  console.log(
-    "✅ Context injection working - tools can access all required services"
-  );
-  console.log("✅ No singleton usage - tools use bound context instead");
-  console.log(
-    "✅ Backward compatibility maintained - existing patterns still work"
-  );
-  console.log("✅ executeScript migrated successfully to dependency injection");
-
-  return true;
-}
-
-// Run the validation tests
-if (require.main === module) {
-  runValidationTests()
-    .then(() => {
-      console.log("\n🏆 Dependency Injection Implementation Complete!");
-      process.exit(0);
-    })
-    .catch((error) => {
-      console.error("\n❌ Validation tests failed:", error);
-      process.exit(1);
-    });
-}
-
-export { runValidationTests, TestAgent1, TestAgent2 };

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

@@ -1,74 +0,0 @@
-#!/usr/bin/env ts-node
-/**
- * Quick test for executeScript - minimal example
- * Usage: npx ts-node src/agents/tools/executeScript/examples/quick-test.ts
- */
-
-import { executeScript } from "../../executeScript";
-import { services } from "../../../../services";
-
-// Simple test script
-const simpleScript = `
-console.log("Hello from executeScript!");
-
-async function main() {
-  // Test basic functionality
-  console.log("Running simple test...");
-
-  // Try a simple tool call
-  const files = await callTool("fileSearch", { searchTerm: "*.ts" });
-  console.log("Found", files?.length || 0, "TypeScript files");
-
-  return {
-    message: "Simple test completed!",
-    filesFound: files?.length || 0,
-    timestamp: new Date().toISOString()
-  };
-}
-
-await main().then(result => {
-  console.log("Result:", result);
-}).catch(error => {
-  console.error("Error:", error);
-});
-`;
-
-async function quickTest() {
-  console.log("🧪 Quick executeScript test\n");
-
-  try {
-    const { Tools, Clients } = services();
-    const result = await executeScript({
-      script: simpleScript,
-      maxToolCalls: 5,
-      maxTokens: 100,
-      maxExecutionTimeMs: 10000,
-      maxCostUsd: 0.1,
-    });
-
-    console.log("\n📊 QUICK TEST RESULT:");
-    console.log("Success:", result.success);
-    console.log("Result:", result.result);
-    console.log("Tool calls:", result.quotaUsage.toolCalls);
-    console.log("Cost: $" + result.quotaUsage.costUsd.toFixed(4));
-
-    if (result.consoleOutput.length > 0) {
-      console.log("\n📝 Console Output:");
-      result.consoleOutput.forEach((entry) => {
-        console.log(`  ${entry}`);
-      });
-    }
-
-    if (!result.success) {
-      console.log("❌ Error:", result.error);
-    }
-  } catch (error) {
-    console.error("💥 Test failed:", error);
-  }
-}
-
-if (require.main === module) {
-  quickTest();
-}
-
-export { quickTest };

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

@@ -1,321 +0,0 @@
-#!/usr/bin/env ts-node
-/**
- * Serialization Test for executeScript - demonstrates transfer issues
- * Usage: npx ts-node src/agents/tools/executeScript/examples/serialization-test.ts
- *
- * This test demonstrates the "A non-transferable value was passed" errors
- * that occur when trying to return complex objects from executeScript.
- */
-
-import { executeScript } from "../../executeScript";
-import { services } from "../../../../services";
-
-interface TestCase {
-  name: string;
-  script: string;
-  expectedToWork: boolean;
-  description: string;
-}
-
-const testCases: TestCase[] = [
-  {
-    name: "primitive-string",
-    expectedToWork: true,
-    description: "Simple string return - should work",
-    script: `
-      console.log("Testing primitive string return");
-      return "Hello World";
-    `,
-  },
-
-  {
-    name: "primitive-number",
-    expectedToWork: true,
-    description: "Simple number return - should work",
-    script: `
-      console.log("Testing primitive number return");
-      return 42;
-    `,
-  },
-
-  {
-    name: "primitive-boolean",
-    expectedToWork: true,
-    description: "Simple boolean return - should work",
-    script: `
-      console.log("Testing primitive boolean return");
-      return true;
-    `,
-  },
-
-  {
-    name: "simple-array",
-    expectedToWork: true, // You mentioned this works
-    description: "Simple array return - you said this works",
-    script: `
-      console.log("Testing simple array return");
-      return [1, 2, 3, "hello"];
-    `,
-  },
-
-  {
-    name: "simple-object",
-    expectedToWork: false, // This is where I got errors
-    description:
-      "Simple object return - expected to fail with transferable error",
-    script: `
-      console.log("Testing simple object return");
-      return {
-        message: "Hello",
-        count: 42,
-        success: true
-      };
-    `,
-  },
-
-  {
-    name: "nested-object",
-    expectedToWork: false,
-    description: "Nested object return - expected to fail",
-    script: `
-      console.log("Testing nested object return");
-      return {
-        data: {
-          items: [1, 2, 3],
-          metadata: { timestamp: new Date().toISOString() }
-        },
-        status: "success"
-      };
-    `,
-  },
-
-  {
-    name: "object-with-functions",
-    expectedToWork: false,
-    description: "Object with functions - definitely should fail",
-    script: `
-      console.log("Testing object with functions");
-      return {
-        data: [1, 2, 3],
-        transform: function(x) { return x * 2; },
-        helper: () => "test"
-      };
-    `,
-  },
-
-  {
-    name: "array-of-objects",
-    expectedToWork: false, // Based on my experience
-    description: "Array containing objects - expected to fail",
-    script: `
-      console.log("Testing array of objects");
-      return [
-        { id: 1, name: "Alice" },
-        { id: 2, name: "Bob" },
-        { id: 3, name: "Charlie" }
-      ];
-    `,
-  },
-
-  {
-    name: "json-stringify-workaround",
-    expectedToWork: true,
-    description: "Using JSON.stringify as workaround - should work",
-    script: `
-      console.log("Testing JSON.stringify workaround");
-      const data = {
-        message: "Hello",
-        items: [1, 2, 3],
-        nested: { key: "value" }
-      };
-      return JSON.stringify(data);
-    `,
-  },
-
-  {
-    name: "tool-call-result",
-    expectedToWork: false, // Based on my experience with news aggregation
-    description: "Tool call result object - expected to fail",
-    script: `
-      console.log("Testing tool call result return");
-
-      try {
-        const searchResult = await callTool("fileSearch", { searchTerm: "package.json" });
-
-        // Try to return a structured response with the tool result
-        return {
-          success: true,
-          toolResult: searchResult,
-          timestamp: new Date().toISOString()
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-    `,
-  },
-
-  {
-    name: "date-object",
-    expectedToWork: false,
-    description: "Date object return - expected to fail",
-    script: `
-      console.log("Testing Date object return");
-      return new Date();
-    `,
-  },
-
-  {
-    name: "map-object",
-    expectedToWork: false,
-    description: "Map object return - expected to fail",
-    script: `
-      console.log("Testing Map object return");
-      const map = new Map();
-      map.set("key1", "value1");
-      map.set("key2", "value2");
-      return map;
-    `,
-  },
-];
-
-async function runSerializationTests() {
-  console.log("🧪 Running executeScript Serialization Tests\\n");
-  console.log("=".repeat(80));
-
-  const results = {
-    passed: 0,
-    failed: 0,
-    unexpected: 0,
-    details: [] as any[],
-  };
-
-  for (const testCase of testCases) {
-    console.log(`\\n📋 Testing: ${testCase.name}`);
-    console.log(`📝 Description: ${testCase.description}`);
-    console.log(`🎯 Expected to work: ${testCase.expectedToWork}`);
-
-    try {
-      const result = await executeScript({
-        script: testCase.script,
-        maxToolCalls: 5,
-        maxTokens: 500,
-        maxExecutionTimeMs: 10000,
-        maxCostUsd: 0.1,
-      });
-
-      const actualWorked = result.success;
-      const matchesExpectation = actualWorked === testCase.expectedToWork;
-
-      if (matchesExpectation) {
-        results.passed++;
-        console.log(`✅ PASS - Behaved as expected`);
-      } else {
-        results.unexpected++;
-        console.log(
-          `⚠️  UNEXPECTED - Expected ${
-            testCase.expectedToWork ? "success" : "failure"
-          }, got ${actualWorked ? "success" : "failure"}`
-        );
-      }
-
-      results.details.push({
-        name: testCase.name,
-        expected: testCase.expectedToWork,
-        actual: actualWorked,
-        matches: matchesExpectation,
-        result: actualWorked ? result.result : null,
-        error: actualWorked ? null : result.error,
-        consoleOutput: result.consoleOutput,
-      });
-
-      if (actualWorked) {
-        console.log(`📊 Result type: ${typeof result.result}`);
-        console.log(
-          `📊 Result: ${JSON.stringify(result.result).substring(0, 200)}${
-            JSON.stringify(result.result).length > 200 ? "..." : ""
-          }`
-        );
-      } else {
-        console.log(`❌ Error: ${result.error}`);
-      }
-
-      if (result.consoleOutput.length > 0) {
-        console.log(`📝 Console: ${result.consoleOutput.join(", ")}`);
-      }
-    } catch (error) {
-      results.failed++;
-      console.log(`💥 TEST FRAMEWORK ERROR: ${error.message}`);
-
-      results.details.push({
-        name: testCase.name,
-        expected: testCase.expectedToWork,
-        actual: false,
-        matches: !testCase.expectedToWork,
-        result: null,
-        error: error.message,
-        consoleOutput: [],
-      });
-    }
-  }
-
-  // Print summary
-  console.log("\\n" + "=".repeat(80));
-  console.log("📊 SERIALIZATION TEST SUMMARY");
-  console.log("=".repeat(80));
-  console.log(`✅ Tests matching expectations: ${results.passed}`);
-  console.log(`⚠️  Unexpected behaviors: ${results.unexpected}`);
-  console.log(`💥 Framework failures: ${results.failed}`);
-  console.log(`📋 Total tests: ${testCases.length}`);
-
-  if (results.unexpected > 0) {
-    console.log("\\n🔍 UNEXPECTED RESULTS:");
-    results.details
-      .filter((d) => !d.matches)
-      .forEach((detail) => {
-        console.log(
-          `  - ${detail.name}: Expected ${
-            detail.expected ? "success" : "failure"
-          }, got ${detail.actual ? "success" : "failure"}`
-        );
-        if (detail.error) {
-          console.log(`    Error: ${detail.error}`);
-        }
-      });
-  }
-
-  // Analysis and recommendations
-  console.log("\\n🔬 ANALYSIS:");
-
-  const workingTypes = results.details
-    .filter((d) => d.actual)
-    .map((d) => d.name);
-  const failingTypes = results.details
-    .filter((d) => !d.actual)
-    .map((d) => d.name);
-
-  console.log("\\n✅ Types that work:");
-  workingTypes.forEach((name) => console.log(`  - ${name}`));
-
-  console.log("\\n❌ Types that fail:");
-  failingTypes.forEach((name) => console.log(`  - ${name}`));
-
-  console.log("\\n💡 RECOMMENDATIONS:");
-  console.log("  1. Use JSON.stringify() for complex objects");
-  console.log("  2. Return primitive values when possible");
-  console.log("  3. Consider createArtifact() for structured data");
-  console.log("  4. Test your return types with this suite");
-
-  return results;
-}
-
-if (require.main === module) {
-  runSerializationTests().catch((error) => {
-    console.error("Test suite failed:", error);
-    process.exit(1);
-  });
-}
-
-export { runSerializationTests, testCases };