@hazeljs/agent 0.2.0-beta.1 → 0.2.0-beta.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 HazelJS Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/benchmarks/performance.benchmark.ts

@@ -0,0 +1,157 @@
+/**
+ * Performance Benchmarks
+ * Measure agent runtime performance under various conditions
+ */
+
+import { AgentRuntime } from '../src/runtime/agent.runtime';
+import { Agent } from '../src/decorators/agent.decorator';
+import { Tool } from '../src/decorators/tool.decorator';
+
+interface BenchmarkResult {
+  name: string;
+  iterations: number;
+  totalTime: number;
+  averageTime: number;
+  minTime: number;
+  maxTime: number;
+  throughput: number;
+}
+
+class PerformanceBenchmark {
+  /**
+   * Run a benchmark
+   */
+  async runBenchmark(
+    name: string,
+    fn: () => Promise<void>,
+    iterations: number = 100
+  ): Promise<BenchmarkResult> {
+    const times: number[] = [];
+    const startTotal = Date.now();
+
+    for (let i = 0; i < iterations; i++) {
+      const start = Date.now();
+      await fn();
+      const duration = Date.now() - start;
+      times.push(duration);
+    }
+
+    const totalTime = Date.now() - startTotal;
+    const averageTime = times.reduce((a, b) => a + b, 0) / times.length;
+    const minTime = Math.min(...times);
+    const maxTime = Math.max(...times);
+    const throughput = (iterations / totalTime) * 1000;
+
+    return {
+      name,
+      iterations,
+      totalTime,
+      averageTime,
+      minTime,
+      maxTime,
+      throughput,
+    };
+  }
+
+  /**
+   * Format benchmark results
+   */
+  formatResults(results: BenchmarkResult[]): string {
+    const lines: string[] = [
+      'Performance Benchmark Results',
+      '============================',
+      '',
+    ];
+
+    for (const result of results) {
+      lines.push(`${result.name}:`);
+      lines.push(`  Iterations: ${result.iterations}`);
+      lines.push(`  Total Time: ${result.totalTime.toFixed(2)}ms`);
+      lines.push(`  Average: ${result.averageTime.toFixed(2)}ms`);
+      lines.push(`  Min: ${result.minTime.toFixed(2)}ms`);
+      lines.push(`  Max: ${result.maxTime.toFixed(2)}ms`);
+      lines.push(`  Throughput: ${result.throughput.toFixed(2)} ops/sec`);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+}
+
+/**
+ * Example benchmarks
+ */
+async function runBenchmarks() {
+  const benchmark = new PerformanceBenchmark();
+  const results: BenchmarkResult[] = [];
+
+  // Benchmark 1: Agent Registration
+  @Agent({ name: 'bench-agent', description: 'Benchmark agent' })
+  class BenchAgent {
+    @Tool({ description: 'Benchmark tool', parameters: [] })
+    async benchTool() {
+      return { result: 'ok' };
+    }
+  }
+
+  const runtime = new AgentRuntime({
+    enableMetrics: true,
+    rateLimitPerMinute: 10000,
+  });
+
+  results.push(
+    await benchmark.runBenchmark(
+      'Agent Registration',
+      async () => {
+        const agent = new BenchAgent();
+        runtime.registerAgentInstance('bench-agent', agent);
+      },
+      1000
+    )
+  );
+
+  // Benchmark 2: Tool Registry Lookup
+  const agent = new BenchAgent();
+  runtime.registerAgentInstance('bench-agent', agent);
+
+  results.push(
+    await benchmark.runBenchmark(
+      'Tool Registry Lookup',
+      async () => {
+        runtime.getAgentTools('bench-agent');
+      },
+      10000
+    )
+  );
+
+  // Benchmark 3: Metrics Collection
+  results.push(
+    await benchmark.runBenchmark(
+      'Metrics Collection',
+      async () => {
+        runtime.getMetrics();
+      },
+      10000
+    )
+  );
+
+  // Benchmark 4: Health Check
+  results.push(
+    await benchmark.runBenchmark(
+      'Health Check',
+      async () => {
+        await runtime.healthCheck();
+      },
+      100
+    )
+  );
+
+  console.log(benchmark.formatResults(results));
+}
+
+// Run benchmarks if executed directly
+if (require.main === module) {
+  runBenchmarks().catch(console.error);
+}
+
+export { PerformanceBenchmark, runBenchmarks };