agentvault 1.0.1 → 1.0.2

package/dist/src/inference/bittensor-client.js

@@ -0,0 +1,224 @@
+/**
+ * Bittensor Client
+ *
+ * Handles interaction with Bittensor network for AI inference queries.
+ * Supports subnet discovery, module queries, and response handling.
+ */
+export class BittensorClient {
+    config;
+    axiosInstance = null;
+    constructor(config = {}) {
+        this.config = {
+            apiEndpoint: config.apiEndpoint || 'https://api.bittensor.com',
+            timeout: config.timeout || 30000,
+            apiKey: config.apiKey || '',
+        };
+    }
+    /**
+     * Initialize HTTP client (lazy loading)
+     */
+    async getClient() {
+        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)
+     */
+    async importAxios() {
+        try {
+            const dynamicImport = new Function('modulePath', 'return import(modulePath)');
+            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() {
+        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) {
+        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) {
+        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, uid) {
+        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) {
+        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, criteria = 'rank') {
+        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, limit = 5) {
+        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) {
+        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() {
+        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',
+            };
+        }
+    }
+}
+//# sourceMappingURL=bittensor-client.js.map

package/dist/src/inference/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Inference Module
+ *
+ * Exports inference functionality.
+ */
+export * from './bittensor-client.js';
+export * from './inference-manager.js';
+//# sourceMappingURL=index.d.ts.map

package/{src/inference/index.ts → dist/src/inference/index.js}

@@ -3,6 +3,6 @@
  *
  * Exports inference functionality.
  */
-
 export * from './bittensor-client.js';
 export * from './inference-manager.js';
+//# sourceMappingURL=index.js.map

package/dist/src/inference/inference-manager.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Inference Manager
+ *
+ * Manages AI inference requests through Bittensor network.
+ * Handles caching, rate limiting, and result aggregation.
+ */
+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;
+}
+/**
+ * Get cached inference result
+ */
+export declare function getCachedInference(netuid: number, inputs: Record<string, any>, _ttlMs?: number): CachedInference | null;
+/**
+ * Set cached inference result
+ */
+export declare function setCachedInference(netuid: number, inputs: Record<string, any>, result: any, ttlMs?: number): void;
+/**
+ * Clear all cached inferences
+ */
+export declare function clearCache(): void;
+/**
+ * Clear expired cached inferences
+ */
+export declare function clearExpiredCache(): number;
+/**
+ * Get cache statistics
+ */
+export declare function getCacheStats(): {
+    total: number;
+    expired: number;
+    sizeBytes: number;
+};
+/**
+ * Aggregate multiple inference results
+ */
+export declare function aggregateResults(results: InferenceResult[], method?: 'average' | 'majority' | 'first'): any;
+/**
+ * Format inference time
+ */
+export declare function formatInferenceTime(ms: number): string;
+/**
+ * Get inference statistics
+ */
+export interface InferenceStats {
+    total: number;
+    success: number;
+    failed: number;
+    cached: number;
+    avgResponseTime: number;
+}
+export declare function getInferenceStats(history: InferenceResult[]): InferenceStats;
+//# sourceMappingURL=inference-manager.d.ts.map

package/dist/src/inference/inference-manager.js

@@ -0,0 +1,228 @@
+/**
+ * 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');
+function ensureCacheDir() {
+    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, inputs) {
+    const sortedInputs = JSON.stringify(inputs, Object.keys(inputs).sort());
+    return `inference-${netuid}-${crypto.createHash('sha256').update(sortedInputs).digest('hex')}`;
+}
+function getCacheFilePath(key) {
+    ensureCacheDir();
+    return path.join(INFERENCE_CACHE_DIR, `${key}.json`);
+}
+/**
+ * Get cached inference result
+ */
+export function getCachedInference(netuid, inputs, _ttlMs = 3600000) {
+    try {
+        const key = generateCacheKey(netuid, inputs);
+        const cachePath = getCacheFilePath(key);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(cachePath, 'utf8');
+        const cached = 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, inputs, result, ttlMs = 3600000) {
+    try {
+        const key = generateCacheKey(netuid, inputs);
+        const cachePath = getCacheFilePath(key);
+        const now = new Date();
+        const cached = {
+            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() {
+    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() {
+    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 = 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() {
+    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 = 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, method = 'majority') {
+    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, r) => sum + r.data, 0) / validResults.length);
+            }
+            return firstResult.data;
+        case 'majority':
+        default: {
+            const counts = new Map();
+            for (const result of validResults) {
+                const key = JSON.stringify(result.data);
+                counts.set(key, (counts.get(key) || 0) + 1);
+            }
+            let maxCount = 0;
+            let majorityResult = 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) {
+    if (ms < 1000) {
+        return `${ms.toFixed(0)}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+export function getInferenceStats(history) {
+    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, t) => sum + t, 0) / responseTimes.length
+            : 0,
+    };
+}
+//# sourceMappingURL=inference-manager.js.map

package/dist/src/metrics/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Metrics Module
+ *
+ * Exports metrics functionality.
+ */
+export * from './metrics.js';
+//# sourceMappingURL=index.d.ts.map

package/{src/metrics/index.ts → dist/src/metrics/index.js}

@@ -3,5 +3,5 @@
  *
  * Exports metrics functionality.
  */
-
 export * from './metrics.js';
+//# sourceMappingURL=index.js.map

package/dist/src/metrics/metrics.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Metrics Module
+ *
+ * Stores and retrieves canister metrics (cycles, memory, messages, etc.)
+ * in JSONL format: ~/.agentvault/metrics/<canister-id>/YYYY-MM-DD.jsonl
+ */
+export type MetricName = 'cycles_balance' | 'memory_heap' | 'message_count' | 'request_count' | 'error_count';
+export interface MetricDataPoint {
+    timestamp: Date;
+    value: number;
+}
+export interface MetricTimeSeries {
+    metric: MetricName;
+    dataPoints: MetricDataPoint[];
+}
+export interface MetricsSummary {
+    canisterId: string;
+    metrics: Record<MetricName, {
+        current: number;
+        min: number;
+        max: number;
+        avg: number;
+        delta?: number;
+    }>;
+    period: {
+        start: Date;
+        end: Date;
+    };
+}
+export interface CollectorConfig {
+    interval?: number;
+    retentionDays?: number;
+}
+export declare function storeMetrics(canisterId: string, metrics: Record<MetricName, number>): void;
+export declare function getTimeSeries(canisterId: string, metric: MetricName, from: Date, to: Date): MetricTimeSeries;
+export declare function getSummary(canisterId: string, days?: number): MetricsSummary;
+export declare function pruneOldData(canisterId: string, retentionDays: number): void;
+export declare function startCollector(canisterId: string, config?: CollectorConfig): NodeJS.Timeout;
+//# sourceMappingURL=metrics.d.ts.map