agentvault 1.0.0

package/src/inference/bittensor-client.ts

@@ -0,0 +1,304 @@
+/**
+ * Bittensor Client
+ *
+ * Handles interaction with Bittensor network for AI inference queries.
+ * Supports subnet discovery, module queries, and response handling.
+ */
+
+
+
+export interface BittensorConfig {
+  apiEndpoint?: string;
+  timeout?: number;
+  apiKey?: string;
+}
+
+export interface SubnetInfo {
+  netuid: number;
+  name: string;
+  founder: string;
+  tempo: number;
+  modality: string;
+  registered: number;
+  last_emit_block: number;
+}
+
+export interface ModuleInfo {
+  uid: number;
+  name: string;
+  address: string;
+  stake: number;
+  dividend: number;
+  emission: number;
+  incentive: number;
+  consensus: number;
+  trust: number;
+  rank: number;
+  validator_permit: boolean;
+}
+
+export interface InferenceRequest {
+  netuid: number;
+  uid?: number;
+  inputs: Record<string, any>;
+  timeout?: number;
+}
+
+export interface InferenceResponse {
+  success: boolean;
+  data?: Record<string, any>;
+  metadata?: {
+    uid: number;
+    name: string;
+    netuid: number;
+    responseTime: number;
+  };
+  error?: string;
+}
+
+export class BittensorClient {
+  private config: Required<BittensorConfig>;
+  private axiosInstance: any = null;
+
+  constructor(config: BittensorConfig = {}) {
+    this.config = {
+      apiEndpoint: config.apiEndpoint || 'https://api.bittensor.com',
+      timeout: config.timeout || 30000,
+      apiKey: config.apiKey || '',
+    };
+  }
+
+  /**
+   * Initialize HTTP client (lazy loading)
+   */
+  private async getClient(): Promise<any> {
+    if (!this.axiosInstance) {
+      const axios = await this.importAxios();
+      this.axiosInstance = axios.create({
+        baseURL: this.config.apiEndpoint,
+        timeout: this.config.timeout,
+        headers: {
+          'Content-Type': 'application/json',
+          ...(this.config.apiKey && { 'X-API-Key': this.config.apiKey }),
+        },
+      });
+    }
+    return this.axiosInstance;
+  }
+
+  /**
+   * Dynamically import axios (optional dependency)
+   */
+  private async importAxios(): Promise<any> {
+    try {
+      const dynamicImport = new Function('modulePath', 'return import(modulePath)') as (
+        modulePath: string
+      ) => Promise<{ default: any }>;
+      const axiosModule = await dynamicImport('axios');
+      return axiosModule.default;
+    } catch (_error) {
+      throw new Error(
+        'axios is required for BittensorClient. Install with: npm install axios',
+      );
+    }
+  }
+
+  /**
+   * Get all subnets
+   */
+  async getSubnets(): Promise<SubnetInfo[]> {
+    try {
+      const client = await this.getClient();
+      const response = await client.get('/subnets');
+
+      return response.data.subnets || [];
+    } catch (error) {
+      console.error('Failed to fetch subnets:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get subnet by ID
+   */
+  async getSubnet(netuid: number): Promise<SubnetInfo | null> {
+    try {
+      const subnets = await this.getSubnets();
+      return subnets.find((s) => s.netuid === netuid) || null;
+    } catch (error) {
+      console.error(`Failed to fetch subnet ${netuid}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Get modules for a subnet
+   */
+  async getModules(netuid: number): Promise<ModuleInfo[]> {
+    try {
+      const client = await this.getClient();
+      const response = await client.get(`/subnets/${netuid}/modules`);
+
+      return response.data.modules || [];
+    } catch (error) {
+      console.error(`Failed to fetch modules for subnet ${netuid}:`, error);
+      return [];
+    }
+  }
+
+  /**
+   * Get module by UID
+   */
+  async getModule(netuid: number, uid: number): Promise<ModuleInfo | null> {
+    try {
+      const modules = await this.getModules(netuid);
+      return modules.find((m) => m.uid === uid) || null;
+    } catch (error) {
+      console.error(`Failed to fetch module ${netuid}/${uid}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Send inference request
+   */
+  async infer(request: InferenceRequest): Promise<InferenceResponse> {
+    const startTime = Date.now();
+
+    try {
+      const client = await this.getClient();
+      const response = await client.post(`/subnets/${request.netuid}/infer`, {
+        uid: request.uid,
+        inputs: request.inputs,
+        timeout: request.timeout || this.config.timeout,
+      });
+
+      const responseTime = Date.now() - startTime;
+
+      if (response.data.success) {
+        return {
+          success: true,
+          data: response.data.output,
+          metadata: {
+            uid: response.data.uid,
+            name: response.data.name,
+            netuid: request.netuid,
+            responseTime,
+          },
+        };
+      } else {
+        return {
+          success: false,
+          error: response.data.error || 'Inference failed',
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  /**
+   * Find best module for a subnet
+   */
+  async findBestModule(
+    netuid: number,
+    criteria: 'stake' | 'trust' | 'rank' | 'consensus' = 'rank',
+  ): Promise<ModuleInfo | null> {
+    try {
+      const modules = await this.getModules(netuid);
+      if (modules.length === 0) {
+        return null;
+      }
+
+      return modules
+        .sort((a, b) => b[criteria] - a[criteria])
+        .slice(0, 1)[0] || null;
+    } catch (error) {
+      console.error('Failed to find best module:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Batch inference to multiple modules
+   */
+  async batchInfer(
+    request: InferenceRequest,
+    limit: number = 5,
+  ): Promise<InferenceResponse[]> {
+    try {
+      const modules = await this.getModules(request.netuid);
+      const topModules = modules
+        .sort((a, b) => b.rank - a.rank)
+        .slice(0, limit);
+
+      const promises = topModules.map((module) =>
+        this.infer({ ...request, uid: module.uid }),
+      );
+
+      return Promise.all(promises);
+    } catch (error) {
+      console.error('Failed to batch infer:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Health check for subnet
+   */
+  async checkSubnetHealth(netuid: number): Promise<{
+    healthy: boolean;
+    moduleCount: number;
+    avgResponseTime: number;
+  }> {
+    const startTime = Date.now();
+
+    try {
+      const modules = await this.getModules(netuid);
+      if (modules.length === 0) {
+        return {
+          healthy: false,
+          moduleCount: 0,
+          avgResponseTime: 0,
+        };
+      }
+
+      const responseTime = Date.now() - startTime;
+
+      return {
+        healthy: true,
+        moduleCount: modules.length,
+        avgResponseTime: responseTime,
+      };
+    } catch (_error) {
+      return {
+        healthy: false,
+        moduleCount: 0,
+        avgResponseTime: 0,
+      };
+    }
+  }
+
+  /**
+   * Get API status
+   */
+  async getApiStatus(): Promise<{ online: boolean; version?: string; error?: string }> {
+    try {
+      const client = await this.getClient();
+      const response = await client.get('/status');
+
+      return {
+        online: response.data.online || false,
+        version: response.data.version,
+      };
+    } catch (error) {
+      return {
+        online: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}

package/src/inference/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Inference Module
+ *
+ * Exports inference functionality.
+ */
+
+export * from './bittensor-client.js';
+export * from './inference-manager.js';

package/src/inference/inference-manager.ts

@@ -0,0 +1,327 @@
+/**
+ * Inference Manager
+ *
+ * Manages AI inference requests through Bittensor network.
+ * Handles caching, rate limiting, and result aggregation.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const INFERENCE_CACHE_DIR = path.join(AGENTVAULT_DIR, 'inference-cache');
+
+export interface InferenceConfig {
+  netuid: number;
+  uid?: number;
+  batchSize?: number;
+  timeout?: number;
+  cacheTTL?: number;
+  enableCache?: boolean;
+}
+
+export interface InferenceResult {
+  success: boolean;
+  data?: any;
+  metadata?: {
+    netuid: number;
+    uid: number;
+    timestamp: Date;
+    responseTime: number;
+  };
+  error?: string;
+}
+
+export interface CachedInference {
+  key: string;
+  request: any;
+  result: any;
+  timestamp: Date;
+  expiresAt: Date;
+}
+
+function ensureCacheDir(): void {
+  if (!fs.existsSync(AGENTVAULT_DIR)) {
+    fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(INFERENCE_CACHE_DIR)) {
+    fs.mkdirSync(INFERENCE_CACHE_DIR, { recursive: true });
+  }
+}
+
+function generateCacheKey(
+  netuid: number,
+  inputs: Record<string, any>,
+): string {
+  const sortedInputs = JSON.stringify(inputs, Object.keys(inputs).sort());
+  return `inference-${netuid}-${crypto.createHash('sha256').update(sortedInputs).digest('hex')}`;
+}
+
+function getCacheFilePath(key: string): string {
+  ensureCacheDir();
+  return path.join(INFERENCE_CACHE_DIR, `${key}.json`);
+}
+
+/**
+ * Get cached inference result
+ */
+export function getCachedInference(
+  netuid: number,
+  inputs: Record<string, any>,
+  _ttlMs: number = 3600000,
+): CachedInference | null {
+  try {
+    const key = generateCacheKey(netuid, inputs);
+    const cachePath = getCacheFilePath(key);
+
+    if (!fs.existsSync(cachePath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(cachePath, 'utf8');
+    const cached: CachedInference = JSON.parse(content);
+
+    if (new Date(cached.expiresAt) < new Date()) {
+      fs.unlinkSync(cachePath);
+      return null;
+    }
+
+    return cached;
+  } catch (error) {
+    console.error('Failed to get cached inference:', error);
+    return null;
+  }
+}
+
+/**
+ * Set cached inference result
+ */
+export function setCachedInference(
+  netuid: number,
+  inputs: Record<string, any>,
+  result: any,
+  ttlMs: number = 3600000,
+): void {
+  try {
+    const key = generateCacheKey(netuid, inputs);
+    const cachePath = getCacheFilePath(key);
+
+    const now = new Date();
+    const cached: CachedInference = {
+      key,
+      request: inputs,
+      result,
+      timestamp: now,
+      expiresAt: new Date(now.getTime() + ttlMs),
+    };
+
+    fs.writeFileSync(cachePath, JSON.stringify(cached), 'utf8');
+  } catch (error) {
+    console.error('Failed to cache inference:', error);
+  }
+}
+
+/**
+ * Clear all cached inferences
+ */
+export function clearCache(): void {
+  try {
+    ensureCacheDir();
+    const files = fs.readdirSync(INFERENCE_CACHE_DIR);
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        const filePath = path.join(INFERENCE_CACHE_DIR, file);
+        fs.unlinkSync(filePath);
+      }
+    }
+  } catch (error) {
+    console.error('Failed to clear cache:', error);
+  }
+}
+
+/**
+ * Clear expired cached inferences
+ */
+export function clearExpiredCache(): number {
+  let cleared = 0;
+
+  try {
+    ensureCacheDir();
+    const files = fs.readdirSync(INFERENCE_CACHE_DIR);
+    const now = new Date();
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        const filePath = path.join(INFERENCE_CACHE_DIR, file);
+        const content = fs.readFileSync(filePath, 'utf8');
+        const cached: CachedInference = JSON.parse(content);
+
+        if (new Date(cached.expiresAt) < now) {
+          fs.unlinkSync(filePath);
+          cleared++;
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Failed to clear expired cache:', error);
+  }
+
+  return cleared;
+}
+
+/**
+ * Get cache statistics
+ */
+export function getCacheStats(): {
+  total: number;
+  expired: number;
+  sizeBytes: number;
+} {
+  try {
+    ensureCacheDir();
+    const files = fs.readdirSync(INFERENCE_CACHE_DIR);
+    const now = new Date();
+    let expired = 0;
+    let sizeBytes = 0;
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        const filePath = path.join(INFERENCE_CACHE_DIR, file);
+        const content = fs.readFileSync(filePath, 'utf8');
+        const cached: CachedInference = JSON.parse(content);
+
+        if (new Date(cached.expiresAt) < now) {
+          expired++;
+        }
+
+        sizeBytes += Buffer.byteLength(content);
+      }
+    }
+
+    return {
+      total: files.length,
+      expired,
+      sizeBytes,
+    };
+  } catch (error) {
+    console.error('Failed to get cache stats:', error);
+    return { total: 0, expired: 0, sizeBytes: 0 };
+  }
+}
+
+/**
+ * Aggregate multiple inference results
+ */
+export function aggregateResults(
+  results: InferenceResult[],
+  method: 'average' | 'majority' | 'first' = 'majority',
+): any {
+  if (results.length === 0) {
+    return null;
+  }
+
+  if (results.length === 1) {
+    return results[0]?.data || null;
+  }
+
+  const validResults = results.filter((r) => r.success && r.data);
+
+  if (validResults.length === 0) {
+    return null;
+  }
+
+  const firstResult = validResults[0];
+  if (!firstResult) {
+    return null;
+  }
+
+  switch (method) {
+    case 'first':
+      return firstResult.data;
+
+    case 'average':
+      if (typeof firstResult.data === 'number') {
+        return (
+          validResults.reduce((sum: number, r: any) => sum + (r.data as number), 0) / validResults.length
+        );
+      }
+      return firstResult.data;
+
+    case 'majority':
+    default: {
+      const counts = new Map<string, number>();
+
+      for (const result of validResults) {
+        const key = JSON.stringify(result.data);
+        counts.set(key, (counts.get(key) || 0) + 1);
+      }
+
+      let maxCount = 0;
+      let majorityResult: any = null;
+
+      for (const [key, count] of counts.entries()) {
+        if (count > maxCount) {
+          maxCount = count;
+          majorityResult = JSON.parse(key);
+        }
+      }
+
+      return majorityResult;
+    }
+  }
+}
+
+/**
+ * Format inference time
+ */
+export function formatInferenceTime(ms: number): string {
+  if (ms < 1000) {
+    return `${ms.toFixed(0)}ms`;
+  }
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+/**
+ * Get inference statistics
+ */
+export interface InferenceStats {
+  total: number;
+  success: number;
+  failed: number;
+  cached: number;
+  avgResponseTime: number;
+}
+
+export function getInferenceStats(
+  history: InferenceResult[],
+): InferenceStats {
+  if (history.length === 0) {
+    return {
+      total: 0,
+      success: 0,
+      failed: 0,
+      cached: 0,
+      avgResponseTime: 0,
+    };
+  }
+
+  const success = history.filter((r) => r.success).length;
+  const cached = history.filter((r) => r.success && r.metadata !== undefined).length;
+  const responseTimes = history
+    .filter((r) => r.metadata)
+    .map((r) => r.metadata!.responseTime);
+
+  return {
+    total: history.length,
+    success,
+    failed: history.length - success,
+    cached,
+    avgResponseTime:
+      responseTimes.length > 0
+        ? responseTimes.reduce((sum: number, t: number) => sum + t, 0) / responseTimes.length
+        : 0,
+  };
+}

package/src/metrics/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Metrics Module
+ *
+ * Exports metrics functionality.
+ */
+
+export * from './metrics.js';