@aiaiaichain/agent 0.1.3 → 0.1.5

package/dist/runner/AgentRunner.js

@@ -2,6 +2,7 @@
  * AgentRunner — main agent loop. Handles tool calling, streaming, and message processing.
  * The AI responds with text or tool calls; we parse, dispatch, and feed results back.
  */
+import { logger } from "../util/logger.js";
 import { ToolDispatcher } from "./ToolDispatcher.js";
 import { ModelClient, resolveModelConfig } from "./ModelClient.js";
 export class AgentRunner {
@@ -17,6 +18,8 @@ export class AgentRunner {
     contextStore;
     abortController = null;
     _pendingApproval;
+    _toolRetries = new Map();
+    _maxToolRetries = 2;
     constructor(registry, session, onEvent, sessionCtx, effectLevel, modelReg, costTracker, goalManager, contextStore) {
         this.registry = registry;
         this.session = session;
@@ -53,7 +56,9 @@ export class AgentRunner {
                     try {
                         args = JSON.parse(toolCallMatch[3]);
                     }
-                    catch { /* use empty args */ }
+                    catch {
+                        logger.warn('AgentRunner', 'Failed to parse tool call args from stream', { toolCall: toolCallMatch[0].slice(0, 100) });
+                    }
                     fullResponse = fullResponse.replace(toolCallMatch[0], "").trim();
                     toolCallBuffer = "";
                     if (toolName !== "noop") {
@@ -130,6 +135,18 @@ export class AgentRunner {
             result: resultText,
             isError: result.isError ?? false,
         });
+        // Break retry loop: don't feed back if tool has failed too many times
+        if (result.isError) {
+            const retries = (this._toolRetries.get(toolName) ?? 0) + 1;
+            this._toolRetries.set(toolName, retries);
+            if (retries > this._maxToolRetries) {
+                this._toolRetries.delete(toolName);
+                return; // Stop feeding errors — prevent loop
+            }
+        }
+        else {
+            this._toolRetries.delete(toolName);
+        }
         // Feed the result back to the model for a follow-up
         const toolMessages = [
             ...messages.slice(-5),

package/dist/runner/ModelClient.js

@@ -3,6 +3,14 @@
  * Handles streaming and non-streaming calls.
  */
 import { env } from "../core/EnvLoader.js";
+import { logger } from "../util/logger.js";
+import { resilientFetch } from "../util/resilientFetch.js";
+const MAX_RETRIES = 2;
+const RETRY_BACKOFF_MS = 1000;
+const REQUEST_TIMEOUT = 60_000;
+function isRetryable(status) {
+    return status === 429 || status >= 500;
+}
 export function resolveModelConfig(registry) {
     const apiKey = env.get("OPENROUTER_API_KEY");
     const defaultModel = env.get("DEFAULT_MODEL");
@@ -24,61 +32,114 @@ export class ModelClient {
             stream: true,
             max_tokens: 4096,
         };
-        try {
-            const response = await fetch(`${config.baseUrl}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${config.apiKey}`,
-                    "HTTP-Referer": "https://aiaiaichain.dev",
-                    "X-Title": "AIAIAI Chain Agent",
-                },
-                body: JSON.stringify(body),
-                signal,
-            });
-            if (!response.ok) {
-                const err = await response.text().catch(() => "unknown error");
-                onEvent({ type: "error", message: `API error ${response.status}: ${err}` });
-                return;
-            }
-            const reader = response.body?.getReader();
-            if (!reader) {
-                onEvent({ type: "error", message: "No response body" });
-                return;
-            }
-            const decoder = new TextDecoder();
-            let buffer = "";
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    const trimmed = line.trim();
-                    if (!trimmed || trimmed === "data: [DONE]")
-                        continue;
-                    if (!trimmed.startsWith("data: "))
+        let lastError = "";
+        let lastStatus = 0;
+        let timer;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = RETRY_BACKOFF_MS * Math.pow(2, attempt - 1);
+                    logger.info('ModelClient', `Retry attempt ${attempt}/${MAX_RETRIES} after ${delay}ms`);
+                    await new Promise(r => setTimeout(r, delay));
+                }
+                const controller = new AbortController();
+                timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+                if (signal?.aborted) {
+                    onEvent({ type: "error", message: "Request aborted" });
+                    return;
+                }
+                const combinedSignal = signal ?? controller.signal;
+                const response = await resilientFetch(`${config.baseUrl}/chat/completions`, {
+                    timeout: REQUEST_TIMEOUT,
+                    retries: 0,
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${config.apiKey}`,
+                        "HTTP-Referer": "https://aiaiaichain.dev",
+                        "X-Title": "AIAIAI Chain Agent",
+                    },
+                    body: JSON.stringify(body),
+                    signal: combinedSignal,
+                });
+                clearTimeout(timer);
+                if (!response.ok) {
+                    const err = await response.text().catch(() => "unknown error");
+                    lastError = err;
+                    lastStatus = response.status;
+                    if (isRetryable(response.status) && attempt < MAX_RETRIES) {
+                        logger.warn('ModelClient', `Retryable error ${response.status}`, { attempt });
                         continue;
-                    try {
-                        const json = JSON.parse(trimmed.slice(6));
-                        const delta = json.choices?.[0]?.delta?.content;
-                        if (delta)
-                            onEvent({ type: "text_delta", text: delta });
                     }
-                    catch { /* skip malformed lines */ }
+                    if (response.status === 401) {
+                        onEvent({ type: "error", message: `API auth failed: OpenRouter key is missing or invalid.\nRun: aiaiai setup\nGet a key: https://openrouter.ai/keys` });
+                    }
+                    else {
+                        onEvent({ type: "error", message: `API error ${response.status}: ${err}` });
+                    }
+                    return;
+                }
+                const reader = response.body?.getReader();
+                if (!reader) {
+                    onEvent({ type: "error", message: "No response body" });
+                    return;
+                }
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed === "data: [DONE]")
+                            continue;
+                        if (!trimmed.startsWith("data: "))
+                            continue;
+                        try {
+                            const json = JSON.parse(trimmed.slice(6));
+                            const delta = json.choices?.[0]?.delta?.content;
+                            if (delta)
+                                onEvent({ type: "text_delta", text: delta });
+                        }
+                        catch {
+                            logger.debug('ModelClient', 'Skipped malformed SSE line', { line: trimmed.slice(0, 100) });
+                        }
+                    }
                 }
-            }
-            onEvent({ type: "turn_done" });
-        }
-        catch (e) {
-            if (e instanceof Error && e.name === "AbortError") {
                 onEvent({ type: "turn_done" });
+                return; // Success — exit retry loop
+            }
+            catch (e) {
+                clearTimeout(timer);
+                if (e instanceof Error && e.name === "AbortError") {
+                    if (signal?.aborted) {
+                        onEvent({ type: "turn_done" });
+                        return;
+                    }
+                    // Timeout
+                    lastError = "Request timed out";
+                    if (attempt < MAX_RETRIES) {
+                        logger.warn('ModelClient', `Timeout, retrying`, { attempt });
+                        continue;
+                    }
+                    onEvent({ type: "error", message: "Request timed out" });
+                    return;
+                }
+                lastError = e instanceof Error ? e.message : String(e);
+                if (attempt < MAX_RETRIES) {
+                    logger.warn('ModelClient', `Error, retrying`, { attempt, error: lastError });
+                    continue;
+                }
+                onEvent({ type: "error", message: `ModelClient error (${lastStatus || 'offline'}): ${lastError}` });
                 return;
             }
-            onEvent({ type: "error", message: e instanceof Error ? e.message : String(e) });
         }
+        // Exhausted retries
+        onEvent({ type: "error", message: `ModelClient failed after ${MAX_RETRIES + 1} attempts: ${lastError}` });
     }
 }
 //# sourceMappingURL=ModelClient.js.map

package/dist/session/SessionManager.d.ts

@@ -10,6 +10,7 @@ export declare class SessionManager {
     private messages;
     private systemPrompt;
     private maxContextTokens;
+    private _cachedChars;
     setSystemPrompt(prompt: string): void;
     getSystemPrompt(): string;
     addMessage(role: string, content: string): void;

package/dist/session/SessionManager.js

@@ -5,6 +5,7 @@ export class SessionManager {
     messages = [];
     systemPrompt = "";
     maxContextTokens = 128_000;
+    _cachedChars = 0;
     setSystemPrompt(prompt) {
         this.systemPrompt = prompt;
     }
@@ -13,13 +14,18 @@ export class SessionManager {
     }
     addMessage(role, content) {
         this.messages.push({ role, content });
+        this._cachedChars += content.length + role.length + 10;
     }
     getMessages() {
         // Estimate: 1 token ≈ 4 chars
         const maxChars = this.maxContextTokens * 4;
+        // Fast path: if total is under limit, return all
+        if (this._cachedChars <= maxChars) {
+            return [...this.messages];
+        }
+        // Slow path: walk backwards until we hit the limit
         let total = 0;
         const result = [];
-        // Walk backwards, building up until we hit the limit
         for (let i = this.messages.length - 1; i >= 0; i--) {
             const msg = this.messages[i];
             const size = msg.content.length + msg.role.length + 10;
@@ -31,7 +37,7 @@ export class SessionManager {
         return result;
     }
     getContextPressure() {
-        const totalChars = this.messages.reduce((sum, m) => sum + m.content.length + m.role.length + 10, 0);
+        const totalChars = this._cachedChars || this.messages.reduce((sum, m) => sum + m.content.length + m.role.length + 10, 0);
         const maxChars = this.maxContextTokens * 4;
         const pct = Math.min(100, Math.round((totalChars / maxChars) * 100));
         let level = "green";

package/dist/session/SessionStore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * SessionStore — saves/loads conversation sessions.
+ * Sessions stored as JSON in ~/.aiaiai/sessions/
+ */
+import type { ChatMessage } from '../tui/REPL.js';
+export interface SessionMeta {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    messageCount: number;
+    model: string;
+}
+export interface Session {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    messages: ChatMessage[];
+    model: string;
+    chain: string;
+}
+export declare class SessionStore {
+    private currentId;
+    private autoSaveInterval;
+    constructor();
+    /** Start auto-saving every 30s */
+    startAutoSave(getMessages: () => ChatMessage[]): void;
+    stopAutoSave(): void;
+    /** Save current session */
+    save(messages: ChatMessage[], title?: string): string;
+    /** Load a session by ID */
+    load(id: string): Session | null;
+    /** List all sessions (most recent first) */
+    list(): SessionMeta[];
+    /** Delete a session */
+    delete(id: string): boolean;
+    /** Set current session ID (for resuming) */
+    setCurrentId(id: string): void;
+    getCurrentId(): string;
+    /** Generate a title from first user message */
+    private generateTitle;
+}
+export declare const sessionStore: SessionStore;
+//# sourceMappingURL=SessionStore.d.ts.map

package/dist/session/SessionStore.js

@@ -0,0 +1,128 @@
+/**
+ * SessionStore — saves/loads conversation sessions.
+ * Sessions stored as JSON in ~/.aiaiai/sessions/
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { logger } from '../util/logger.js';
+const SESSIONS_DIR = resolve(homedir(), '.aiaiai', 'sessions');
+function ensureDir() {
+    if (!existsSync(SESSIONS_DIR))
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function sessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+export class SessionStore {
+    currentId;
+    autoSaveInterval = null;
+    constructor() {
+        ensureDir();
+        this.currentId = sessionId();
+    }
+    /** Start auto-saving every 30s */
+    startAutoSave(getMessages) {
+        this.stopAutoSave();
+        this.autoSaveInterval = setInterval(() => {
+            const msgs = getMessages();
+            if (msgs.length > 0)
+                this.save(msgs, 'current');
+        }, 30_000);
+    }
+    stopAutoSave() {
+        if (this.autoSaveInterval) {
+            clearInterval(this.autoSaveInterval);
+            this.autoSaveInterval = null;
+        }
+    }
+    /** Save current session */
+    save(messages, title) {
+        ensureDir();
+        const id = this.currentId;
+        const existing = this.load(id);
+        const session = {
+            id,
+            title: title || existing?.title || this.generateTitle(messages),
+            createdAt: existing?.createdAt || Date.now(),
+            updatedAt: Date.now(),
+            messages,
+            model: process.env.DEFAULT_MODEL || 'unknown',
+            chain: 'solana',
+        };
+        try {
+            writeFileSync(resolve(SESSIONS_DIR, `${id}.json`), JSON.stringify(session, null, 2), 'utf-8');
+        }
+        catch { /* non-fatal */ }
+        return id;
+    }
+    /** Load a session by ID */
+    load(id) {
+        try {
+            const path = resolve(SESSIONS_DIR, `${id}.json`);
+            if (!existsSync(path))
+                return null;
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch (error) {
+            logger.debug('SessionStore', 'Failed to load session', { error: error.message });
+            return null;
+        }
+    }
+    /** List all sessions (most recent first) */
+    list() {
+        ensureDir();
+        try {
+            const files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+            const sessions = [];
+            for (const file of files) {
+                try {
+                    const data = JSON.parse(readFileSync(resolve(SESSIONS_DIR, file), 'utf-8'));
+                    sessions.push({
+                        id: data.id,
+                        title: data.title,
+                        createdAt: data.createdAt,
+                        updatedAt: data.updatedAt,
+                        messageCount: data.messages.length,
+                        model: data.model,
+                    });
+                }
+                catch (error) {
+                    logger.debug('SessionStore', 'Skipped bad session file', { error: error.message });
+                }
+            }
+            return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+        }
+        catch (error) {
+            logger.warn('SessionStore', 'Failed to list sessions', { error: error.message });
+            return [];
+        }
+    }
+    /** Delete a session */
+    delete(id) {
+        try {
+            unlinkSync(resolve(SESSIONS_DIR, `${id}.json`));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Set current session ID (for resuming) */
+    setCurrentId(id) {
+        this.currentId = id;
+    }
+    getCurrentId() {
+        return this.currentId;
+    }
+    /** Generate a title from first user message */
+    generateTitle(messages) {
+        const firstUser = messages.find(m => m.role === 'user');
+        if (!firstUser)
+            return 'New Session';
+        const text = firstUser.content.trim();
+        return text.length > 40 ? text.slice(0, 37) + '…' : text;
+    }
+}
+export const sessionStore = new SessionStore();
+//# sourceMappingURL=SessionStore.js.map

package/dist/tools/CrossTools.d.ts

@@ -0,0 +1,52 @@
+/**
+ * CrossTools — automation tools that combine multiple data sources.
+ * Watch tokens, compare, portfolio tracking, price alerts.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+interface PriceAlert {
+    id: string;
+    token: string;
+    type: 'above' | 'below';
+    price: number;
+    active: boolean;
+    createdAt: number;
+    triggeredAt?: number;
+}
+export declare function addAlert(token: string, type: 'above' | 'below', price: number): PriceAlert;
+export declare function checkAlerts(currentPrice: number, token: string): PriceAlert[];
+export declare function getActiveAlerts(): PriceAlert[];
+export declare function addToWatchList(tokenAddress: string): void;
+export declare function removeFromWatchList(tokenAddress: string): void;
+export declare function getWatchList(): string[];
+export declare const watchTokenParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const removeWatchParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const listWatchParams: import("@sinclair/typebox").TObject<{}>;
+export declare const addAlertParams: import("@sinclair/typebox").TObject<{
+    token: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TString;
+    price: import("@sinclair/typebox").TNumber;
+}>;
+export declare const checkAlertsParams: import("@sinclair/typebox").TObject<{}>;
+export declare const compareTokensParams: import("@sinclair/typebox").TObject<{
+    address1: import("@sinclair/typebox").TString;
+    address2: import("@sinclair/typebox").TString;
+}>;
+export declare function watchTokenTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare function removeWatchTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare function listWatchTool(): Promise<ToolResult>;
+export declare function addAlertTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare function checkAlertsTool(): Promise<ToolResult>;
+export declare function compareTokensTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare const portfolioParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare function portfolioTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export declare const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+export declare const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
+export {};
+//# sourceMappingURL=CrossTools.d.ts.map