@aiaiaichain/agent 0.1.5 → 0.1.7

package/dist/runner/AgentRunner.js

@@ -1,188 +1,184 @@
-/**
- * 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 {
-    registry;
-    session;
-    dispatcher;
-    onEvent;
-    sessionCtx;
-    effectLevel;
-    modelReg;
-    costTracker;
-    goalManager;
-    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;
-        this.dispatcher = new ToolDispatcher(registry);
-        this.onEvent = onEvent;
-        this.sessionCtx = sessionCtx;
-        this.effectLevel = effectLevel;
-        this.modelReg = modelReg;
-        this.costTracker = costTracker;
-        this.goalManager = goalManager;
-        this.contextStore = contextStore;
-    }
-    setEffectLevel(level) {
-        this.effectLevel = level;
-    }
-    async run(input) {
-        this.session.addMessage("user", input);
-        const config = resolveModelConfig(this.modelReg);
-        const messages = this.session.getMessages();
-        const systemPrompt = this.session.getSystemPrompt();
-        let fullResponse = "";
-        let toolCallBuffer = "";
-        this.abortController = new AbortController();
-        const handleEvent = (event) => {
-            if (event.type === "text_delta") {
-                fullResponse += event.text;
-                // Check for tool call patterns
-                toolCallBuffer += event.text;
-                // Simple JSON tool call detection
-                const toolCallMatch = toolCallBuffer.match(/\{("tool"|"name"):\s*"([^"]+)"\s*,\s*"args"|"params"|"parameters":\s*(\{[^}]+\})\s*\}/);
-                if (toolCallMatch) {
-                    const toolName = toolCallMatch[2];
-                    let args = {};
-                    try {
-                        args = JSON.parse(toolCallMatch[3]);
-                    }
-                    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") {
-                        this.onEvent({ type: "tool_start", name: toolName });
-                        // Check if tool requires approval
-                        const tool = this.dispatcher.getTool(toolName);
-                        if (tool && this.requiresApproval(toolName)) {
-                            this.onEvent({
-                                type: "approval_request",
-                                toolName,
-                                args: JSON.stringify(args),
-                                approve: (ok) => {
-                                    if (ok) {
-                                        this.executeTool(toolName, args, fullResponse, systemPrompt, messages, config);
-                                    }
-                                    else {
-                                        this.onEvent({
-                                            type: "tool_done",
-                                            name: toolName,
-                                            result: JSON.stringify({ error: "User denied approval" }),
-                                            isError: true,
-                                        });
-                                        this.session.addMessage("assistant", fullResponse || `(tool ${toolName} was denied)`);
-                                        this.onEvent({ type: "turn_done" });
-                                    }
-                                },
-                            });
-                            return;
-                        }
-                        this.executeTool(toolName, args, fullResponse, systemPrompt, messages, config);
-                    }
-                }
-                this.onEvent({ type: "text_delta", text: event.text });
-            }
-            else if (event.type === "turn_done") {
-                if (fullResponse.trim()) {
-                    this.session.addMessage("assistant", fullResponse.trim());
-                    if (this.costTracker) {
-                        this.costTracker.track(config.model, messages.reduce((s, m) => s + m.content.length, 0), fullResponse.length);
-                    }
-                }
-                this.onEvent({ type: "turn_done" });
-            }
-            else if (event.type === "error") {
-                // Check if it's a streaming error that might be tool-call related
-                if (toolCallBuffer.includes("tool") || toolCallBuffer.includes("function")) {
-                    // Try to extract tool name from error
-                    const nameMatch = toolCallBuffer.match(/"name"\s*:\s*"([^"]+)"/);
-                    const name = nameMatch ? nameMatch[1] : "unknown";
-                    this.onEvent({
-                        type: "tool_done",
-                        name,
-                        result: JSON.stringify({ error: event.message }),
-                        isError: true,
-                    });
-                }
-                this.onEvent({ type: "error", message: event.message ?? "unknown error" });
-            }
-        };
-        await ModelClient.runStreaming({
-            config,
-            systemPrompt,
-            messages,
-            onEvent: handleEvent,
-            signal: this.abortController.signal,
-        });
-    }
-    async executeTool(toolName, args, responseSoFar, systemPrompt, messages, config) {
-        const result = await this.dispatcher.dispatch(toolName, args);
-        const resultText = result.content.map(c => c.text).join("\n");
-        this.onEvent({
-            type: "tool_done",
-            name: toolName,
-            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),
-            { role: "assistant", content: responseSoFar || `(using ${toolName})` },
-            { role: "user", content: `Tool "${toolName}" returned:\n${resultText}\n\nSummarize the result or continue.` },
-        ];
-        let secondResponse = "";
-        await ModelClient.runStreaming({
-            config,
-            systemPrompt,
-            messages: toolMessages,
-            onEvent: (event) => {
-                if (event.type === "text_delta") {
-                    secondResponse += event.text;
-                    this.onEvent({ type: "text_delta", text: event.text });
-                }
-                else if (event.type === "turn_done") {
-                    if (secondResponse.trim()) {
-                        this.session.addMessage("assistant", secondResponse.trim());
-                    }
-                    this.onEvent({ type: "turn_done" });
-                }
-                else if (event.type === "error") {
-                    this.onEvent({ type: "error", message: event.message ?? "unknown error" });
-                }
-            },
-            signal: this.abortController?.signal,
-        });
-    }
-    requiresApproval(toolName) {
-        const approvalTools = ["execute_trade", "send_transaction", "sign_message", "deploy_contract"];
-        return approvalTools.includes(toolName);
-    }
-    abort() {
-        this.abortController?.abort();
-        this.abortController = null;
-    }
-}
-//# sourceMappingURL=AgentRunner.js.map
+registry;
+session;
+dispatcher;
+onEvent;
+sessionCtx;
+effectLevel;
+modelReg;
+costTracker;
+goalManager;
+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;
+this.dispatcher = new ToolDispatcher(registry);
+this.onEvent = onEvent;
+this.sessionCtx = sessionCtx;
+this.effectLevel = effectLevel;
+this.modelReg = modelReg;
+this.costTracker = costTracker;
+this.goalManager = goalManager;
+this.contextStore = contextStore;
+}
+setEffectLevel(level) {
+this.effectLevel = level;
+}
+async run(input) {
+this.session.addMessage("user", input);
+const config = resolveModelConfig(this.modelReg);
+const messages = this.session.getMessages();
+const systemPrompt = this.session.getSystemPrompt();
+let fullResponse = "";
+let toolCallBuffer = "";
+this.abortController = new AbortController();
+const handleEvent = (event) => {
+if (event.type === "text_delta") {
+fullResponse += event.text;
+
+toolCallBuffer += event.text;
+
+const toolCallMatch = toolCallBuffer.match(/\{("tool"|"name"):\s*"([^"]+)"\s*,\s*"args"|"params"|"parameters":\s*(\{[^}]+\})\s*\}/);
+if (toolCallMatch) {
+const toolName = toolCallMatch[2];
+let args = {};
+try {
+args = JSON.parse(toolCallMatch[3]);
+}
+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") {
+this.onEvent({ type: "tool_start", name: toolName });
+
+const tool = this.dispatcher.getTool(toolName);
+if (tool && this.requiresApproval(toolName)) {
+this.onEvent({
+type: "approval_request",
+toolName,
+args: JSON.stringify(args),
+approve: (ok) => {
+if (ok) {
+this.executeTool(toolName, args, fullResponse, systemPrompt, messages, config);
+}
+else {
+this.onEvent({
+type: "tool_done",
+name: toolName,
+result: JSON.stringify({ error: "User denied approval" }),
+isError: true,
+});
+this.session.addMessage("assistant", fullResponse || `(tool ${toolName} was denied)`);
+this.onEvent({ type: "turn_done" });
+}
+},
+});
+return;
+}
+this.executeTool(toolName, args, fullResponse, systemPrompt, messages, config);
+}
+}
+this.onEvent({ type: "text_delta", text: event.text });
+}
+else if (event.type === "turn_done") {
+if (fullResponse.trim()) {
+this.session.addMessage("assistant", fullResponse.trim());
+if (this.costTracker) {
+this.costTracker.track(config.model, messages.reduce((s, m) => s + m.content.length, 0), fullResponse.length);
+}
+}
+this.onEvent({ type: "turn_done" });
+}
+else if (event.type === "error") {
+
+if (toolCallBuffer.includes("tool") || toolCallBuffer.includes("function")) {
+
+const nameMatch = toolCallBuffer.match(/"name"\s*:\s*"([^"]+)"/);
+const name = nameMatch ? nameMatch[1] : "unknown";
+this.onEvent({
+type: "tool_done",
+name,
+result: JSON.stringify({ error: event.message }),
+isError: true,
+});
+}
+this.onEvent({ type: "error", message: event.message ?? "unknown error" });
+}
+};
+await ModelClient.runStreaming({
+config,
+systemPrompt,
+messages,
+onEvent: handleEvent,
+signal: this.abortController.signal,
+});
+}
+async executeTool(toolName, args, responseSoFar, systemPrompt, messages, config) {
+const result = await this.dispatcher.dispatch(toolName, args);
+const resultText = result.content.map(c => c.text).join("\n");
+this.onEvent({
+type: "tool_done",
+name: toolName,
+result: resultText,
+isError: result.isError ?? false,
+});
+
+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; 
+}
+}
+else {
+this._toolRetries.delete(toolName);
+}
+
+const toolMessages = [
+...messages.slice(-5),
+{ role: "assistant", content: responseSoFar || `(using ${toolName})` },
+{ role: "user", content: `Tool "${toolName}" returned:\n${resultText}\n\nSummarize the result or continue.` },
+];
+let secondResponse = "";
+await ModelClient.runStreaming({
+config,
+systemPrompt,
+messages: toolMessages,
+onEvent: (event) => {
+if (event.type === "text_delta") {
+secondResponse += event.text;
+this.onEvent({ type: "text_delta", text: event.text });
+}
+else if (event.type === "turn_done") {
+if (secondResponse.trim()) {
+this.session.addMessage("assistant", secondResponse.trim());
+}
+this.onEvent({ type: "turn_done" });
+}
+else if (event.type === "error") {
+this.onEvent({ type: "error", message: event.message ?? "unknown error" });
+}
+},
+signal: this.abortController?.signal,
+});
+}
+requiresApproval(toolName) {
+const approvalTools = ["execute_trade", "send_transaction", "sign_message", "deploy_contract"];
+return approvalTools.includes(toolName);
+}
+abort() {
+this.abortController?.abort();
+this.abortController = null;
+}
+}

package/dist/runner/ModelClient.d.ts

@@ -27,4 +27,3 @@ export interface ModelClientOptions {
 export declare class ModelClient {
     static runStreaming(options: ModelClientOptions): Promise<void>;
 }
-//# sourceMappingURL=ModelClient.d.ts.map

package/dist/runner/ModelClient.js

@@ -1,7 +1,4 @@
-/**
- * ModelClient — LLM API client for OpenRouter.
- * Handles streaming and non-streaming calls.
- */
+
 import { env } from "../core/EnvLoader.js";
 import { logger } from "../util/logger.js";
 import { resilientFetch } from "../util/resilientFetch.js";
@@ -9,137 +6,139 @@ const MAX_RETRIES = 2;
 const RETRY_BACKOFF_MS = 1000;
 const REQUEST_TIMEOUT = 60_000;
 function isRetryable(status) {
-    return status === 429 || status >= 500;
+return status === 429 || status >= 500;
 }
 export function resolveModelConfig(registry) {
-    const apiKey = env.get("OPENROUTER_API_KEY");
-    const defaultModel = env.get("DEFAULT_MODEL");
-    return {
-        model: defaultModel || registry.resolvePrimary(),
-        apiKey: apiKey || "",
-        baseUrl: "https://openrouter.ai/api/v1",
-    };
+const apiKey = env.get("OPENROUTER_API_KEY");
+const defaultModel = env.get("DEFAULT_MODEL");
+return {
+model: defaultModel || registry.resolvePrimary(),
+apiKey: apiKey || "",
+baseUrl: "https://openrouter.ai/api/v1",
+};
 }
 export class ModelClient {
-    static async runStreaming(options) {
-        const { config, systemPrompt, messages, onEvent, signal } = options;
-        const body = {
-            model: config.model,
-            messages: [
-                { role: "system", content: systemPrompt },
-                ...messages,
-            ],
-            stream: true,
-            max_tokens: 4096,
-        };
-        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;
-                    }
-                    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" });
-                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;
-            }
-        }
-        // Exhausted retries
-        onEvent({ type: "error", message: `ModelClient failed after ${MAX_RETRIES + 1} attempts: ${lastError}` });
-    }
-}
-//# sourceMappingURL=ModelClient.js.map
+static async runStreaming(options) {
+const { config, systemPrompt, messages, onEvent, signal } = options;
+const body = {
+model: config.model,
+messages: [
+{ role: "system", content: systemPrompt },
+...messages,
+],
+stream: true,
+max_tokens: 4096,
+};
+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;
+}
+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 textStream = response.body.pipeThrough(new TextDecoderStream());
+const lineReader = textStream.getReader();
+let buffer = "";
+while (true) {
+const { done, value } = await lineReader.read();
+if (done)
+break;
+buffer += value;
+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" });
+return; 
+}
+catch (e) {
+clearTimeout(timer);
+if (e instanceof Error && e.name === "AbortError") {
+if (signal?.aborted) {
+onEvent({ type: "turn_done" });
+return;
+}
+
+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: `ModelClient failed after ${MAX_RETRIES + 1} attempts: ${lastError}` });
+}
+}