@aiaiaichain/agent 0.1.5 → 0.1.7

package/dist/util/errorHandler.js

@@ -1,28 +1,25 @@
-/**
- * Global error handling utilities for AIAIAI agent
- */
+
 import { safeLog } from "./safeLog.js";
-// Generic error handler to wrap async operations
+
 export function withErrorHandling(operation, context) {
-    return operation().catch((error) => {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        safeLog(`[${context}] ERROR: ${errorMessage}`);
-        if (error instanceof Error) {
-            safeLog(`Stack trace: ${error.stack}`);
-        }
-        throw error; // Re-throw to maintain expected behavior
-    });
+return operation().catch((error) => {
+const errorMessage = error instanceof Error ? error.message : String(error);
+safeLog(`[${context}] ERROR: ${errorMessage}`);
+if (error instanceof Error) {
+safeLog(`Stack trace: ${error.stack}`);
 }
-// Enhanced logging for unhandled promise rejections
+throw error; 
+});
+}
+
 export function setupGlobalErrorHandlers() {
-    process.on('unhandledRejection', (reason, promise) => {
-        console.error('[UNHANDLED_REJECTION] Reason:', reason);
-        console.error('[PROMISE]', promise);
-        process.exit(1);
-    });
-    process.on('uncaughtException', (error) => {
-        console.error('[UNCAUGHT_EXCEPTION]', error);
-        process.exit(1);
-    });
+process.on('unhandledRejection', (reason, promise) => {
+console.error('[UNHANDLED_REJECTION] Reason:', reason);
+console.error('[PROMISE]', promise);
+process.exit(1);
+});
+process.on('uncaughtException', (error) => {
+console.error('[UNCAUGHT_EXCEPTION]', error);
+process.exit(1);
+});
 }
-//# sourceMappingURL=errorHandler.js.map

package/dist/util/errors.d.ts

@@ -0,0 +1,59 @@
+/**
+ * #61: Structured error types with codes for consistent error handling
+ * #65: Error code system — AUTH_401, RATE_429, TIMEOUT_408, etc.
+ */
+export type ErrorCode = 'AUTH_401' | 'RATE_429' | 'TIMEOUT_408' | 'PARSE_001' | 'RPC_ERROR' | 'NETWORK_ERROR' | 'VALIDATION_ERROR' | 'TOOL_ERROR' | 'UNKNOWN';
+export declare class AgentError extends Error {
+    readonly code: ErrorCode;
+    readonly context?: Record<string, unknown>;
+    readonly timestamp: number;
+    readonly recoverable: boolean;
+    constructor(message: string, code?: ErrorCode, options?: {
+        context?: Record<string, unknown>;
+        recoverable?: boolean;
+    });
+}
+export declare class RpcError extends AgentError {
+    readonly method: string;
+    readonly statusCode?: number;
+    constructor(message: string, method: string, options?: {
+        statusCode?: number;
+        code?: ErrorCode;
+        context?: Record<string, unknown>;
+    });
+}
+export declare class ApiError extends AgentError {
+    readonly host: string;
+    readonly statusCode?: number;
+    constructor(message: string, host: string, options?: {
+        statusCode?: number;
+        code?: ErrorCode;
+        recoverable?: boolean;
+    });
+}
+export declare class ValidationError extends AgentError {
+    readonly field: string;
+    constructor(message: string, field: string, context?: Record<string, unknown>);
+}
+/**
+ * #62: Error aggregation — collect errors per session for /errors command
+ */
+declare class ErrorAggregator {
+    private errors;
+    private maxErrors;
+    record(error: AgentError): void;
+    getRecent(count?: number): Array<{
+        error: AgentError;
+        ts: number;
+    }>;
+    getByCode(code: ErrorCode): AgentError[];
+    getSummary(): Record<string, number>;
+    clear(): void;
+    get count(): number;
+}
+export declare const errorAggregator: ErrorAggregator;
+/**
+ * #66: User-friendly error messages with suggested actions
+ */
+export declare function formatUserError(error: AgentError): string;
+export {};

package/dist/util/errors.js

@@ -0,0 +1,93 @@
+
+export class AgentError extends Error {
+code;
+context;
+timestamp;
+recoverable;
+constructor(message, code = 'UNKNOWN', options) {
+super(message);
+this.name = 'AgentError';
+this.code = code;
+this.context = options?.context;
+this.timestamp = Date.now();
+this.recoverable = options?.recoverable ?? false;
+}
+}
+export class RpcError extends AgentError {
+method;
+statusCode;
+constructor(message, method, options) {
+super(message, options?.code ?? 'RPC_ERROR', options);
+this.name = 'RpcError';
+this.method = method;
+this.statusCode = options?.statusCode;
+}
+}
+export class ApiError extends AgentError {
+host;
+statusCode;
+constructor(message, host, options) {
+super(message, options?.code ?? 'NETWORK_ERROR', options);
+this.name = 'ApiError';
+this.host = host;
+this.statusCode = options?.statusCode;
+}
+}
+export class ValidationError extends AgentError {
+field;
+constructor(message, field, context) {
+super(message, 'VALIDATION_ERROR', { context, recoverable: true });
+this.name = 'ValidationError';
+this.field = field;
+}
+}
+
+class ErrorAggregator {
+errors = [];
+maxErrors = 100;
+record(error) {
+this.errors.push({ error, ts: Date.now() });
+if (this.errors.length > this.maxErrors) {
+this.errors = this.errors.slice(-this.maxErrors);
+}
+}
+getRecent(count = 20) {
+return this.errors.slice(-count);
+}
+getByCode(code) {
+return this.errors.filter(e => e.error.code === code).map(e => e.error);
+}
+getSummary() {
+const summary = {};
+for (const { error } of this.errors) {
+summary[error.code] = (summary[error.code] ?? 0) + 1;
+}
+return summary;
+}
+clear() {
+this.errors = [];
+}
+get count() {
+return this.errors.length;
+}
+}
+export const errorAggregator = new ErrorAggregator();
+
+export function formatUserError(error) {
+switch (error.code) {
+case 'AUTH_401':
+return `Authentication failed. Run: aiaiai setup`;
+case 'RATE_429':
+return `Rate limited. Wait a moment and try again.`;
+case 'TIMEOUT_408':
+return `Request timed out. Check your connection or try again.`;
+case 'RPC_ERROR':
+return `Solana RPC error. The network may be congested. Try again in 30s.`;
+case 'NETWORK_ERROR':
+return `Network error. Check your internet connection.`;
+case 'VALIDATION_ERROR':
+return `Invalid input: ${error.message}`;
+default:
+return error.message;
+}
+}

package/dist/util/logger.d.ts

@@ -8,4 +8,3 @@ export declare const logger: {
     warn(context: string, message: string, meta?: unknown): void;
     error(context: string, message: string, meta?: unknown): void;
 };
-//# sourceMappingURL=logger.d.ts.map

package/dist/util/logger.js

@@ -1,43 +1,40 @@
-/**
- * src/util/logger.ts — Structured logging with levels for AIAIAI Agent
- */
+
 const LEVEL_PRIORITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
+debug: 0,
+info: 1,
+warn: 2,
+error: 3,
 };
 function getMinLevel() {
-    const env = process.env.AIAIAI_LOG_LEVEL?.toLowerCase();
-    if (env && env in LEVEL_PRIORITY)
-        return env;
-    return 'info';
+const env = process.env.AIAIAI_LOG_LEVEL?.toLowerCase();
+if (env && env in LEVEL_PRIORITY)
+return env;
+return 'info';
 }
 function shouldLog(level) {
-    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[getMinLevel()];
+return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[getMinLevel()];
 }
 function formatMessage(level, context, message, meta) {
-    const ts = new Date().toISOString();
-    const prefix = `[${ts}] [${level.toUpperCase()}] [${context}]`;
-    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
-    return `${prefix} ${message}${metaStr}`;
+const ts = new Date().toISOString();
+const prefix = `[${ts}] [${level.toUpperCase()}] [${context}]`;
+const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+return `${prefix} ${message}${metaStr}`;
 }
 export const logger = {
-    debug(context, message, meta) {
-        if (shouldLog('debug'))
-            console.error(formatMessage('debug', context, message, meta));
-    },
-    info(context, message, meta) {
-        if (shouldLog('info'))
-            console.error(formatMessage('info', context, message, meta));
-    },
-    warn(context, message, meta) {
-        if (shouldLog('warn'))
-            console.error(formatMessage('warn', context, message, meta));
-    },
-    error(context, message, meta) {
-        if (shouldLog('error'))
-            console.error(formatMessage('error', context, message, meta));
-    },
+debug(context, message, meta) {
+if (shouldLog('debug'))
+console.error(formatMessage('debug', context, message, meta));
+},
+info(context, message, meta) {
+if (shouldLog('info'))
+console.error(formatMessage('info', context, message, meta));
+},
+warn(context, message, meta) {
+if (shouldLog('warn'))
+console.error(formatMessage('warn', context, message, meta));
+},
+error(context, message, meta) {
+if (shouldLog('error'))
+console.error(formatMessage('error', context, message, meta));
+},
 };
-//# sourceMappingURL=logger.js.map

package/dist/util/processManager.d.ts

@@ -2,4 +2,3 @@ export declare class ProcessManager {
     static setupGlobalHandlers(): void;
     static shutdown(exitCode: number): void;
 }
-//# sourceMappingURL=processManager.d.ts.map

package/dist/util/processManager.js

@@ -1,39 +1,36 @@
-/**
- * Process management utilities for AIAIAI Agent
- */
+
 import { safeLog } from "./safeLog.js";
 export class ProcessManager {
-    static setupGlobalHandlers() {
-        // Handle uncaught exceptions
-        process.on('uncaughtException', (error) => {
-            safeLog('[UNCAUGHT_EXCEPTION] ' + error.message);
-            if (error.stack) {
-                safeLog('[STACK_TRACE] ' + error.stack);
-            }
-            // Gracefully shutdown
-            this.shutdown(1);
-        });
-        // Handle unhandled promises
-        process.on('unhandledRejection', (reason, promise) => {
-            safeLog('[UNHANDLED_REJECTION] ' + reason?.message || String(reason));
-            // Attempt graceful shutdown
-            this.shutdown(1);
-        });
-        // Handle graceful shutdown signals
-        process.on('SIGTERM', () => {
-            safeLog('[SIGTERM] Received shutdown signal');
-            this.shutdown(0);
-        });
-        process.on('SIGINT', () => {
-            safeLog('[SIGINT] Received shutdown signal');
-            this.shutdown(0);
-        });
-    }
-    static shutdown(exitCode) {
-        // Allow cleanup time
-        setTimeout(() => {
-            process.exit(exitCode);
-        }, 100);
-    }
+static setupGlobalHandlers() {
+
+process.on('uncaughtException', (error) => {
+safeLog('[UNCAUGHT_EXCEPTION] ' + error.message);
+if (error.stack) {
+safeLog('[STACK_TRACE] ' + error.stack);
+}
+
+this.shutdown(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+safeLog('[UNHANDLED_REJECTION] ' + reason?.message || String(reason));
+
+this.shutdown(1);
+});
+
+process.on('SIGTERM', () => {
+safeLog('[SIGTERM] Received shutdown signal');
+this.shutdown(0);
+});
+process.on('SIGINT', () => {
+safeLog('[SIGINT] Received shutdown signal');
+this.shutdown(0);
+});
+}
+static shutdown(exitCode) {
+
+setTimeout(() => {
+process.exit(exitCode);
+}, 100);
+}
 }
-//# sourceMappingURL=processManager.js.map

package/dist/util/resilientFetch.d.ts

@@ -17,5 +17,10 @@ export interface CircuitState {
     state: "closed" | "open" | "half-open";
 }
 export declare function resilientFetch(url: string, options?: FetchOptions): Promise<Response>;
+export declare function getCircuitStats(): Array<{
+    key: string;
+    state: string;
+    failures: number;
+    lastFailureTime: number;
+}>;
 export declare function isReachable(url: string, timeout?: number): Promise<boolean>;
-//# sourceMappingURL=resilientFetch.d.ts.map

package/dist/util/resilientFetch.js

@@ -1,94 +1,148 @@
-/**
- * src/util/resilientFetch.ts - Resilient HTTP client with timeout, retry, circuit breaker
- */
+
+import dns from 'node:dns';
+import http from 'node:http';
+import https from 'node:https';
+import { AgentError, errorAggregator } from './errors.js';
+
+let _requestIdCounter = 0;
+
+const dnsCache = new Map();
+const DNS_CACHE_TTL = 5 * 60_1000; 
+const dnsCacheTime = new Map();
 const circuits = new Map();
 const CIRCUIT_THRESHOLD = 3;
 const CIRCUIT_RESET_MS = 60_000;
+
+const keepAliveAgent = new http.Agent({ keepAlive: true, maxSockets: 10, maxFreeSockets: 5 });
+const httpsKeepAliveAgent = new https.Agent({ keepAlive: true, maxSockets: 10, maxFreeSockets: 5 });
 function getCircuit(key) {
-    let c = circuits.get(key);
-    if (!c) {
-        c = { failures: 0, lastFailureTime: 0, state: "closed" };
-        circuits.set(key, c);
-    }
-    return c;
+let c = circuits.get(key);
+if (!c) {
+c = { failures: 0, lastFailureTime: 0, state: "closed" };
+circuits.set(key, c);
+}
+return c;
 }
 function canExecute(key) {
-    const c = getCircuit(key);
-    if (c.state === "closed")
-        return true;
-    if (c.state === "open" && Date.now() - c.lastFailureTime > CIRCUIT_RESET_MS) {
-        c.state = "half-open";
-        return true;
-    }
-    return c.state === "half-open";
+const c = getCircuit(key);
+if (c.state === "closed")
+return true;
+if (c.state === "open" && Date.now() - c.lastFailureTime > CIRCUIT_RESET_MS) {
+c.state = "half-open";
+return true;
+}
+return c.state === "half-open";
 }
 function recordSuccess(key) {
-    const c = getCircuit(key);
-    c.failures = 0;
-    c.state = "closed";
+const c = getCircuit(key);
+c.failures = 0;
+c.state = "closed";
 }
 function recordFailure(key) {
-    const c = getCircuit(key);
-    c.failures++;
-    c.lastFailureTime = Date.now();
-    if (c.failures >= CIRCUIT_THRESHOLD) {
-        c.state = "open";
-    }
+const c = getCircuit(key);
+c.failures++;
+c.lastFailureTime = Date.now();
+if (c.failures >= CIRCUIT_THRESHOLD) {
+c.state = "open";
+}
 }
 export async function resilientFetch(url, options = {}) {
-    const { timeout = 8_000, retries = 2, backoffMs = 1_000, onRetry, method = "GET", headers, body, signal: externalSignal, } = options;
-    const circuitKey = new URL(url).hostname;
-    if (!canExecute(circuitKey)) {
-        throw new Error("Circuit open for " + circuitKey + " - service unavailable, retry later");
-    }
-    let lastError = null;
-    for (let attempt = 0; attempt <= retries; attempt++) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeout);
-        // Combine external abort signal with timeout
-        if (externalSignal) {
-            if (externalSignal.aborted)
-                controller.abort();
-            else
-                externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
-        }
-        try {
-            const response = await fetch(url, {
-                signal: controller.signal,
-                method,
-                headers,
-                body,
-            });
-            clearTimeout(timer);
-            if (!response.ok) {
-                throw new Error("HTTP " + response.status + ": " + response.statusText);
-            }
-            recordSuccess(circuitKey);
-            return response;
-        }
-        catch (error) {
-            clearTimeout(timer);
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (attempt < retries) {
-                onRetry?.(attempt + 1, lastError);
-                const delay = backoffMs * Math.pow(2, attempt);
-                await new Promise((r) => setTimeout(r, delay));
-            }
-        }
-    }
-    recordFailure(circuitKey);
-    throw lastError;
+const { timeout = 8_000, retries = 2, backoffMs = 1_000, onRetry, method = "GET", headers, body, signal: externalSignal, } = options;
+const circuitKey = new URL(url).hostname;
+if (!canExecute(circuitKey)) {
+throw new Error("Circuit open for " + circuitKey + " - service unavailable, retry later");
+}
+let lastError = null;
+for (let attempt = 0; attempt <= retries; attempt++) {
+const controller = new AbortController();
+const timer = setTimeout(() => controller.abort(), timeout);
+
+if (externalSignal) {
+if (externalSignal.aborted)
+controller.abort();
+else
+externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+}
+try {
+
+const urlObj = new URL(url);
+const hostname = urlObj.hostname;
+const now = Date.now();
+const cachedIp = dnsCache.get(hostname);
+const cachedTime = dnsCacheTime.get(hostname);
+if (!cachedIp || !cachedTime || now - cachedTime > DNS_CACHE_TTL) {
+try {
+dns.resolve4(hostname, (err, ips) => {
+if (!err && ips && ips.length > 0) {
+dnsCache.set(hostname, ips[0]);
+dnsCacheTime.set(hostname, now);
+}
+});
+}
+catch {  }
+}
+
+const agent = urlObj.protocol === 'https:' ? httpsKeepAliveAgent : keepAliveAgent;
+
+const fetchHeaders = { ...headers, 'Accept-Encoding': 'gzip' };
+const fetchOpts = {
+signal: controller.signal,
+method,
+headers: fetchHeaders,
+body,
+};
+
+if (urlObj.protocol === 'https:' || urlObj.protocol === 'http:') {
+fetchOpts.agent = urlObj.protocol === 'https:' ? httpsKeepAliveAgent : keepAliveAgent;
+}
+const response = await fetch(url, fetchOpts);
+clearTimeout(timer);
+if (!response.ok) {
+throw new Error("HTTP " + response.status + ": " + response.statusText);
+}
+recordSuccess(circuitKey);
+return response;
+}
+catch (error) {
+clearTimeout(timer);
+lastError = error instanceof Error ? error : new Error(String(error));
+if (attempt < retries) {
+onRetry?.(attempt + 1, lastError);
+
+const baseDelay = backoffMs * Math.pow(2, attempt);
+const jitter = baseDelay * 0.2 * (Math.random() * 2 - 1);
+await new Promise((r) => setTimeout(r, baseDelay + jitter));
+}
+}
+}
+recordFailure(circuitKey);
+
+if (lastError) {
+const aggError = new AgentError(lastError.message, 'NETWORK_ERROR', {
+context: { url, attempts: retries + 1 },
+recoverable: true,
+});
+errorAggregator.record(aggError);
+}
+throw lastError;
+}
+
+export function getCircuitStats() {
+const stats = [];
+for (const [key, c] of circuits) {
+stats.push({ key, state: c.state, failures: c.failures, lastFailureTime: c.lastFailureTime });
+}
+return stats;
 }
 export async function isReachable(url, timeout = 5_000) {
-    try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeout);
-        const res = await fetch(url, { signal: controller.signal });
-        clearTimeout(timer);
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=resilientFetch.js.map
+try {
+const controller = new AbortController();
+const timer = setTimeout(() => controller.abort(), timeout);
+const res = await fetch(url, { signal: controller.signal });
+clearTimeout(timer);
+return res.ok;
+}
+catch {
+return false;
+}
+}

package/dist/util/responseCache.d.ts

@@ -24,4 +24,3 @@ export declare function cacheStats(): {
     size: number;
     entries: string[];
 };
-//# sourceMappingURL=responseCache.d.ts.map