agentvault 1.0.1 → 1.0.2

package/src/inference/bittensor-client.ts

@@ -1,304 +0,0 @@
-/**
- * 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/inference-manager.ts

@@ -1,327 +0,0 @@
-/**
- * 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,
-  };
-}