evolcore 0.0.4 → 0.0.6

package/dist/agents/ecagent-runner.js

@@ -0,0 +1,1159 @@
+import fs from 'fs';
+import path from 'path';
+import { AgentHarness, JsonlSessionRepo, NodeExecutionEnv, } from '../../ecagent/dist/node.js';
+import { Type, createModels, createProvider, } from '../../ecagent/dist/runtime/index.js';
+import { AssistantMessageEventStream } from '../../ecagent/dist/runtime/utils/event-stream.js';
+import { DEFAULT_PERMISSION_MODE } from '../types.js';
+import { agentSessionsDir, resolveRoot } from '../paths.js';
+import { requestDangerousCommandPermission } from '../core/permission/approval-gateway.js';
+import { normalizePermissionMode } from '../core/permission/mode.js';
+import { checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
+import { logger } from '../utils/logger.js';
+import { resolveEcagentConfig } from './baseagent.js';
+const PROVIDER_ID = 'evolcore-gateway';
+const DEFAULT_SYSTEM_PROMPT = `You are ecagent, the coding agent built into EvolCore.
+Work directly in the current project. Inspect relevant files before changing them, keep edits scoped, and verify the result.
+Use the provided tools for filesystem and shell work. Never claim a tool action succeeded unless its result confirms success.`;
+const MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
+const MODEL_LIST_TIMEOUT_MS = 8_000;
+const MAX_READ_BYTES = 1024 * 1024;
+const MAX_TOOL_OUTPUT = 200_000;
+const MAX_SCAN_FILES = 5_000;
+const MAX_SEARCH_RESULTS = 500;
+const DEFAULT_BASH_TIMEOUT_MS = 120_000;
+class AsyncEventQueue {
+    values = [];
+    waiters = [];
+    ended = false;
+    push(value) {
+        if (this.ended)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter({ value, done: false });
+        else
+            this.values.push(value);
+    }
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        for (const waiter of this.waiters.splice(0))
+            waiter({ value: undefined, done: true });
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.values.length > 0) {
+                yield this.values.shift();
+                continue;
+            }
+            if (this.ended)
+                return;
+            const next = await new Promise(resolve => this.waiters.push(resolve));
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+}
+function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function createAssistantMessage(model) {
+    return {
+        role: 'assistant',
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: emptyUsage(),
+        stopReason: 'stop',
+        timestamp: Date.now(),
+    };
+}
+function clonePartial(message) {
+    return { ...message, content: message.content.map(block => ({ ...block })) };
+}
+function errorMessage(model, error, aborted) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        ...createAssistantMessage(model),
+        stopReason: aborted ? 'aborted' : 'error',
+        errorMessage: message,
+    };
+}
+function truncate(value, max = MAX_TOOL_OUTPUT) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}\n... [truncated ${value.length - max} characters]`;
+}
+function responseHeaders(headers) {
+    return Object.fromEntries(headers.entries());
+}
+function toOpenAiContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return String(content ?? '');
+    const output = [];
+    for (const block of content) {
+        if (block?.type === 'text')
+            output.push({ type: 'text', text: block.text ?? '' });
+        if (block?.type === 'image') {
+            output.push({
+                type: 'image_url',
+                image_url: { url: `data:${block.mimeType || 'image/png'};base64,${block.data}` },
+            });
+        }
+    }
+    return output;
+}
+function openAiMessages(context) {
+    const messages = [];
+    if (context.systemPrompt)
+        messages.push({ role: 'system', content: context.systemPrompt });
+    for (const message of context.messages) {
+        if (message.role === 'user') {
+            messages.push({ role: 'user', content: toOpenAiContent(message.content) });
+            continue;
+        }
+        if (message.role === 'assistant') {
+            const text = message.content
+                .filter((block) => block.type === 'text')
+                .map(block => block.text)
+                .join('');
+            const thinking = message.content
+                .filter((block) => block.type === 'thinking')
+                .map((block) => block.thinking)
+                .join('');
+            const toolCalls = message.content
+                .filter((block) => block.type === 'toolCall')
+                .map((block) => ({
+                id: block.id,
+                type: 'function',
+                function: { name: block.name, arguments: JSON.stringify(block.arguments ?? {}) },
+            }));
+            messages.push({
+                role: 'assistant',
+                content: text || null,
+                ...(thinking ? { reasoning_content: thinking } : {}),
+                ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+            });
+            continue;
+        }
+        const content = message.content
+            .filter((block) => block.type === 'text')
+            .map(block => block.text)
+            .join('\n');
+        messages.push({ role: 'tool', tool_call_id: message.toolCallId, name: message.toolName, content });
+    }
+    return messages;
+}
+async function* readSseEvents(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            buffer += decoder.decode(value, { stream: !done }).replace(/\r\n/g, '\n');
+            let boundary;
+            while ((boundary = buffer.indexOf('\n\n')) >= 0) {
+                const block = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = block.split('\n')
+                    .filter(line => line.startsWith('data:'))
+                    .map(line => line.slice(5).trimStart())
+                    .join('\n');
+                if (data)
+                    yield data;
+            }
+            if (done)
+                break;
+        }
+        const data = buffer.split('\n')
+            .filter(line => line.startsWith('data:'))
+            .map(line => line.slice(5).trimStart())
+            .join('\n');
+        if (data)
+            yield data;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function retryDelay(response, attempt, cap) {
+    const retryAfter = response?.headers.get('retry-after');
+    const requested = retryAfter && Number.isFinite(Number(retryAfter)) ? Number(retryAfter) * 1000 : undefined;
+    const exponential = Math.min(250 * (2 ** attempt), cap || 4_000);
+    return Math.max(0, Math.min(requested ?? exponential, cap || exponential));
+}
+function delay(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        let timer;
+        const cleanup = () => signal?.removeEventListener('abort', abort);
+        const complete = () => { cleanup(); resolve(); };
+        timer = setTimeout(complete, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            cleanup();
+            reject(signal?.reason instanceof Error ? signal.reason : new Error('Request aborted'));
+        };
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+function createOpenAiTransport(config) {
+    const stream = (model, context, options) => {
+        const output = new AssistantMessageEventStream();
+        void (async () => {
+            const hasToolResults = context.messages.some(message => message.role === 'toolResult');
+            const attempts = hasToolResults ? 1 : Math.max(1, config.maxRetries + 1);
+            let lastError;
+            for (let attempt = 0; attempt < attempts; attempt++) {
+                let response;
+                let retryScheduled = false;
+                const controller = new AbortController();
+                const onAbort = () => controller.abort(options?.signal?.reason);
+                options?.signal?.addEventListener('abort', onAbort, { once: true });
+                const timeout = setTimeout(() => controller.abort(new Error(`Gateway request timed out after ${config.timeoutMs}ms`)), config.timeoutMs);
+                try {
+                    let payload = {
+                        model: model.id,
+                        messages: openAiMessages(context),
+                        tools: context.tools?.map(tool => ({
+                            type: 'function',
+                            function: { name: tool.name, description: tool.description, parameters: tool.parameters },
+                        })),
+                        tool_choice: context.tools?.length ? 'auto' : undefined,
+                        stream: true,
+                        stream_options: { include_usage: true },
+                        max_tokens: options?.maxTokens ?? model.maxTokens,
+                        ...(options?.reasoning ? { reasoning_effort: options.reasoning } : {}),
+                    };
+                    const replacement = await options?.onPayload?.(payload, model);
+                    if (replacement !== undefined)
+                        payload = replacement;
+                    response = await fetch(`${model.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
+                        method: 'POST',
+                        headers: {
+                            accept: 'text/event-stream',
+                            authorization: `Bearer ${config.apiKey}`,
+                            'content-type': 'application/json',
+                            ...Object.fromEntries(Object.entries(options?.headers ?? {}).filter((entry) => entry[1] !== null)),
+                        },
+                        body: JSON.stringify(payload),
+                        signal: controller.signal,
+                    });
+                    await options?.onResponse?.({ status: response.status, headers: responseHeaders(response.headers) }, model);
+                    if (!response.ok) {
+                        const body = truncate(await response.text(), 2_000);
+                        const kind = response.status === 401 || response.status === 403 ? 'auth' : 'network';
+                        const error = new Error(`[${kind}] Gateway HTTP ${response.status}: ${body || response.statusText}`);
+                        throw error;
+                    }
+                    if (!response.body)
+                        throw new Error('[network] Gateway response has no body');
+                    await consumeOpenAiStream(output, response.body, model);
+                    return;
+                }
+                catch (error) {
+                    controller.abort();
+                    lastError = error;
+                    const aborted = options?.signal?.aborted === true;
+                    const status = response?.status;
+                    const retryableHttp = response === undefined || status === 429 || (status !== undefined && status >= 500);
+                    const retryable = !aborted
+                        && retryableHttp
+                        && !(error instanceof Error && /\[auth\]/.test(error.message));
+                    if (retryable && attempt + 1 < attempts) {
+                        retryScheduled = true;
+                    }
+                    else {
+                        const message = errorMessage(model, error, aborted);
+                        output.push({ type: 'error', reason: aborted ? 'aborted' : 'error', error: message });
+                        return;
+                    }
+                }
+                finally {
+                    clearTimeout(timeout);
+                    options?.signal?.removeEventListener('abort', onAbort);
+                }
+                if (retryScheduled) {
+                    try {
+                        await delay(retryDelay(response, attempt, config.maxRetryDelayMs), options?.signal);
+                    }
+                    catch (error) {
+                        const aborted = options?.signal?.aborted === true;
+                        const message = errorMessage(model, error, aborted);
+                        output.push({ type: 'error', reason: aborted ? 'aborted' : 'error', error: message });
+                        return;
+                    }
+                }
+            }
+            const message = errorMessage(model, lastError ?? new Error('Gateway request failed'), false);
+            output.push({ type: 'error', reason: 'error', error: message });
+        })();
+        return output;
+    };
+    return { stream, streamSimple: stream };
+}
+async function consumeOpenAiStream(output, body, model) {
+    const message = createAssistantMessage(model);
+    const toolCalls = new Map();
+    let textIndex;
+    let thinkingIndex;
+    let finishReason;
+    let responseId;
+    let responseModel;
+    output.push({ type: 'start', partial: clonePartial(message) });
+    const finish = () => {
+        if (thinkingIndex !== undefined) {
+            const content = message.content[thinkingIndex].thinking;
+            output.push({ type: 'thinking_end', contentIndex: thinkingIndex, content, partial: clonePartial(message) });
+        }
+        if (textIndex !== undefined) {
+            const content = message.content[textIndex].text;
+            output.push({ type: 'text_end', contentIndex: textIndex, content, partial: clonePartial(message) });
+        }
+        for (const call of [...toolCalls.values()].sort((a, b) => a.contentIndex - b.contentIndex)) {
+            let args;
+            try {
+                args = call.arguments.trim() ? JSON.parse(call.arguments) : {};
+            }
+            catch {
+                throw new Error(`[network] Invalid tool arguments for ${call.name}`);
+            }
+            const toolCall = { type: 'toolCall', id: call.id, name: call.name, arguments: args };
+            message.content[call.contentIndex] = toolCall;
+            output.push({ type: 'toolcall_end', contentIndex: call.contentIndex, toolCall, partial: clonePartial(message) });
+        }
+        message.stopReason = toolCalls.size > 0 || finishReason === 'tool_calls'
+            ? 'toolUse'
+            : finishReason === 'length' ? 'length' : 'stop';
+        message.responseId = responseId;
+        message.responseModel = responseModel;
+        message.timestamp = Date.now();
+        output.push({ type: 'done', reason: message.stopReason, message });
+    };
+    let sawDone = false;
+    for await (const data of readSseEvents(body)) {
+        if (data === '[DONE]') {
+            sawDone = true;
+            finish();
+            return;
+        }
+        let chunk;
+        try {
+            chunk = JSON.parse(data);
+        }
+        catch {
+            throw new Error('[network] Gateway returned malformed SSE JSON');
+        }
+        responseId = typeof chunk.id === 'string' ? chunk.id : responseId;
+        responseModel = typeof chunk.model === 'string' ? chunk.model : responseModel;
+        if (chunk.usage) {
+            const promptTokens = Number(chunk.usage.prompt_tokens) || 0;
+            const cachedTokens = Number(chunk.usage.prompt_tokens_details?.cached_tokens) || 0;
+            // OpenAI reports prompt_tokens inclusive of cached_tokens; ecagent's
+            // usage contract stores cacheRead separately so context totals do not
+            // double-count the cached portion.
+            message.usage.input = Math.max(0, promptTokens - cachedTokens);
+            message.usage.output = Number(chunk.usage.completion_tokens) || 0;
+            message.usage.cacheRead = cachedTokens;
+            message.usage.cacheWrite = 0;
+            message.usage.totalTokens = Number(chunk.usage.total_tokens) || message.usage.input + message.usage.output;
+        }
+        const choice = chunk.choices?.[0];
+        if (!choice)
+            continue;
+        if (choice.finish_reason)
+            finishReason = choice.finish_reason;
+        const delta = choice.delta ?? {};
+        const reasoning = delta.reasoning_content ?? delta.reasoning ?? delta.thinking;
+        if (typeof reasoning === 'string' && reasoning) {
+            if (thinkingIndex === undefined) {
+                thinkingIndex = message.content.length;
+                message.content.push({ type: 'thinking', thinking: '' });
+                output.push({ type: 'thinking_start', contentIndex: thinkingIndex, partial: clonePartial(message) });
+            }
+            message.content[thinkingIndex].thinking += reasoning;
+            output.push({ type: 'thinking_delta', contentIndex: thinkingIndex, delta: reasoning, partial: clonePartial(message) });
+        }
+        if (typeof delta.content === 'string' && delta.content) {
+            if (textIndex === undefined) {
+                textIndex = message.content.length;
+                message.content.push({ type: 'text', text: '' });
+                output.push({ type: 'text_start', contentIndex: textIndex, partial: clonePartial(message) });
+            }
+            message.content[textIndex].text += delta.content;
+            output.push({ type: 'text_delta', contentIndex: textIndex, delta: delta.content, partial: clonePartial(message) });
+        }
+        for (const update of delta.tool_calls ?? []) {
+            const index = Number(update.index) || 0;
+            let call = toolCalls.get(index);
+            if (!call) {
+                const contentIndex = message.content.length;
+                call = { contentIndex, id: update.id ?? `call_${index}`, name: '', arguments: '' };
+                toolCalls.set(index, call);
+                message.content.push({ type: 'toolCall', id: call.id, name: '', arguments: {} });
+                output.push({ type: 'toolcall_start', contentIndex, partial: clonePartial(message) });
+            }
+            if (typeof update.id === 'string')
+                call.id = update.id;
+            if (typeof update.function?.name === 'string')
+                call.name += update.function.name;
+            if (typeof update.function?.arguments === 'string') {
+                call.arguments += update.function.arguments;
+                output.push({ type: 'toolcall_delta', contentIndex: call.contentIndex, delta: update.function.arguments, partial: clonePartial(message) });
+            }
+        }
+    }
+    if (!sawDone && finishReason) {
+        finish();
+        return;
+    }
+    throw new Error('[network] Gateway stream ended without a terminal event');
+}
+function createModel(id, baseUrl) {
+    const isClaude = id.toLowerCase().startsWith('claude-');
+    return {
+        id,
+        name: id,
+        api: 'openai-completions',
+        provider: PROVIDER_ID,
+        baseUrl,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: isClaude ? 200_000 : 128_000,
+        maxTokens: isClaude ? 8_192 : 16_384,
+        compat: {
+            maxTokensField: 'max_tokens',
+            supportsUsageInStreaming: true,
+            supportsReasoningEffort: true,
+        },
+    };
+}
+function normalizeThinkingLevel(value) {
+    return ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(value ?? '')
+        ? value
+        : 'off';
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function resolveToolPath(projectPath, candidate, forWrite = false) {
+    const root = fs.realpathSync(projectPath);
+    const resolved = path.resolve(root, candidate || '.');
+    if (!isWithin(root, resolved))
+        throw new Error(`Path is outside the project: ${candidate}`);
+    const existing = forWrite ? path.dirname(resolved) : resolved;
+    let cursor = existing;
+    while (!fs.existsSync(cursor) && cursor !== path.dirname(cursor))
+        cursor = path.dirname(cursor);
+    const canonical = fs.realpathSync(cursor);
+    if (!isWithin(root, canonical))
+        throw new Error(`Path resolves outside the project: ${candidate}`);
+    return resolved;
+}
+function globRegex(pattern) {
+    let source = '^';
+    for (let index = 0; index < pattern.length; index++) {
+        const char = pattern[index];
+        if (char === '*') {
+            if (pattern[index + 1] === '*' && pattern[index + 2] === '/') {
+                source += '(?:.*/)?';
+                index += 2;
+            }
+            else if (pattern[index + 1] === '*') {
+                source += '.*';
+                index++;
+            }
+            else
+                source += '[^/]*';
+        }
+        else if (char === '?')
+            source += '[^/]';
+        else
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+    return new RegExp(`${source}$`);
+}
+async function walkFiles(root, signal) {
+    const output = [];
+    const stack = [root];
+    while (stack.length > 0 && output.length < MAX_SCAN_FILES) {
+        if (signal?.aborted)
+            throw new Error('Tool execution aborted');
+        const dir = stack.pop();
+        for (const entry of await fs.promises.readdir(dir, { withFileTypes: true })) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                stack.push(full);
+            else if (entry.isFile())
+                output.push(full);
+            if (output.length >= MAX_SCAN_FILES)
+                break;
+        }
+    }
+    return output;
+}
+function textResult(text, details = {}) {
+    return { content: [{ type: 'text', text: truncate(text) }], details };
+}
+function createTools(env, projectPath, runtimeEnv) {
+    const read = {
+        name: 'Read', label: 'Read', description: 'Read a UTF-8 text file from the project.',
+        parameters: Type.Object({
+            file_path: Type.String(),
+            offset: Type.Optional(Type.Number({ minimum: 1 })),
+            limit: Type.Optional(Type.Number({ minimum: 1 })),
+        }),
+        async execute(_id, params, signal) {
+            const file = resolveToolPath(projectPath, params.file_path);
+            const stat = await fs.promises.stat(file);
+            if (stat.size > MAX_READ_BYTES)
+                throw new Error(`File exceeds ${MAX_READ_BYTES} byte read limit`);
+            const value = await fs.promises.readFile(file, { encoding: 'utf8', signal });
+            if (value.includes('\0'))
+                throw new Error('Binary files are not supported');
+            const lines = value.split('\n');
+            const offset = Math.max(1, params.offset ?? 1);
+            const selected = lines.slice(offset - 1, params.limit ? offset - 1 + params.limit : undefined);
+            return textResult(selected.map((line, index) => `${offset + index}\t${line}`).join('\n'), { file });
+        },
+    };
+    const glob = {
+        name: 'Glob', label: 'Glob', description: 'Find project files matching a glob pattern.',
+        parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()) }),
+        async execute(_id, params, signal) {
+            const root = resolveToolPath(projectPath, params.path ?? '.');
+            const matcher = globRegex(params.pattern.replaceAll('\\', '/'));
+            const files = (await walkFiles(root, signal))
+                .map(file => path.relative(root, file).replaceAll(path.sep, '/'))
+                .filter(file => matcher.test(file))
+                .slice(0, MAX_SEARCH_RESULTS);
+            return textResult(files.join('\n') || 'No files matched.', { count: files.length });
+        },
+    };
+    const grep = {
+        name: 'Grep', label: 'Grep', description: 'Search text files in the project.',
+        parameters: Type.Object({
+            pattern: Type.String(), path: Type.Optional(Type.String()), glob: Type.Optional(Type.String()),
+            case_insensitive: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()),
+        }),
+        async execute(_id, params, signal) {
+            const root = resolveToolPath(projectPath, params.path ?? '.');
+            const files = (await fs.promises.stat(root)).isFile() ? [root] : await walkFiles(root, signal);
+            const fileMatcher = params.glob ? globRegex(params.glob.replaceAll('\\', '/')) : undefined;
+            const flags = params.case_insensitive ? 'i' : '';
+            const pattern = new RegExp(params.literal ? params.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : params.pattern, flags);
+            const matches = [];
+            for (const file of files) {
+                if (signal?.aborted)
+                    throw new Error('Tool execution aborted');
+                const relative = path.relative(projectPath, file).replaceAll(path.sep, '/');
+                if (fileMatcher && !fileMatcher.test(relative))
+                    continue;
+                const stat = await fs.promises.stat(file);
+                if (stat.size > MAX_READ_BYTES)
+                    continue;
+                const value = await fs.promises.readFile(file, 'utf8').catch(() => '');
+                if (value.includes('\0'))
+                    continue;
+                value.split('\n').forEach((line, index) => {
+                    if (matches.length < MAX_SEARCH_RESULTS && pattern.test(line))
+                        matches.push(`${relative}:${index + 1}:${truncate(line, 1_000)}`);
+                    pattern.lastIndex = 0;
+                });
+                if (matches.length >= MAX_SEARCH_RESULTS)
+                    break;
+            }
+            return textResult(matches.join('\n') || 'No matches found.', { count: matches.length });
+        },
+    };
+    const write = {
+        name: 'Write', label: 'Write', description: 'Create or completely overwrite a project file.',
+        parameters: Type.Object({ file_path: Type.String(), content: Type.String() }), executionMode: 'sequential',
+        async execute(_id, params, signal) {
+            const file = resolveToolPath(projectPath, params.file_path, true);
+            await fs.promises.mkdir(path.dirname(file), { recursive: true });
+            await fs.promises.writeFile(file, params.content, { encoding: 'utf8', signal });
+            return textResult(`Wrote ${Buffer.byteLength(params.content)} bytes to ${path.relative(projectPath, file)}`, { file });
+        },
+    };
+    const edit = {
+        name: 'Edit', label: 'Edit', description: 'Replace an exact string in a project file.',
+        parameters: Type.Object({
+            file_path: Type.String(), old_string: Type.String(), new_string: Type.String(),
+            replace_all: Type.Optional(Type.Boolean()),
+        }), executionMode: 'sequential',
+        async execute(_id, params, signal) {
+            const file = resolveToolPath(projectPath, params.file_path);
+            const value = await fs.promises.readFile(file, { encoding: 'utf8', signal });
+            if (!params.old_string)
+                throw new Error('old_string must not be empty');
+            const count = value.split(params.old_string).length - 1;
+            if (count === 0)
+                throw new Error('old_string was not found');
+            if (count > 1 && !params.replace_all)
+                throw new Error(`old_string matched ${count} locations; set replace_all or provide more context`);
+            const next = params.replace_all
+                ? value.split(params.old_string).join(params.new_string)
+                : value.replace(params.old_string, params.new_string);
+            await fs.promises.writeFile(file, next, { encoding: 'utf8', signal });
+            return textResult(`Updated ${path.relative(projectPath, file)} (${params.replace_all ? count : 1} replacement${count === 1 ? '' : 's'})`, { file, replacements: params.replace_all ? count : 1 });
+        },
+    };
+    const bash = {
+        name: 'Bash', label: 'Bash', description: 'Run a shell command in the project.',
+        parameters: Type.Object({
+            command: Type.String(), timeout: Type.Optional(Type.Number({ minimum: 1, maximum: 600_000 })),
+            description: Type.Optional(Type.String()),
+        }), executionMode: 'sequential',
+        async execute(_id, params, signal) {
+            const result = await env.exec(params.command, {
+                cwd: projectPath,
+                env: runtimeEnv,
+                timeout: params.timeout ?? DEFAULT_BASH_TIMEOUT_MS,
+                abortSignal: signal,
+            });
+            if (!result.ok)
+                throw result.error;
+            const combined = [result.value.stdout, result.value.stderr].filter(Boolean).join('\n');
+            if (result.value.exitCode !== 0)
+                throw new Error(`Command exited with ${result.value.exitCode}\n${truncate(combined)}`);
+            return textResult(combined || `Command exited with ${result.value.exitCode}`, { exitCode: result.value.exitCode });
+        },
+    };
+    return [read, glob, grep, write, edit, bash];
+}
+function extractToolResult(result) {
+    const content = Array.isArray(result?.content) ? result.content : [];
+    return content.filter((block) => block?.type === 'text').map((block) => block.text).join('\n');
+}
+function errorType(message) {
+    const normalized = message.toLowerCase();
+    if (normalized.includes('[auth]') || normalized.includes('401') || normalized.includes('403'))
+        return 'auth';
+    if (normalized.includes('context') && (normalized.includes('long') || normalized.includes('length')))
+        return 'context_too_long';
+    if (normalized.includes('[network]') || normalized.includes('fetch') || normalized.includes('timeout') || normalized.includes('gateway'))
+        return 'network';
+    return 'unknown';
+}
+export class EcagentRunner {
+    name = 'ecagent';
+    capabilities = {
+        clear: true, compact: true, fork: true, askUserQuestion: false, planApproval: false, fileRewind: 'unsupported',
+    };
+    config;
+    onSessionIdUpdate;
+    model;
+    effort;
+    permissionMode = DEFAULT_PERMISSION_MODE;
+    runtimes = new Map();
+    activeStreams = new Map();
+    pendingInterrupts = new Set();
+    permissionContexts = new Map();
+    permissionGateway;
+    sendPromptFn;
+    onCompactStart;
+    modelCache;
+    constructor(config, callbacks) {
+        this.config = config;
+        this.model = config.model;
+        this.effort = config.effort;
+        this.onSessionIdUpdate = callbacks?.onSessionIdUpdate;
+    }
+    sessionsRoot() {
+        if (!this.config.evolcoreAgentAid)
+            throw new Error('ecagent requires an EvolCore Agent AID');
+        return agentSessionsDir(this.config.evolcoreAgentAid);
+    }
+    setModel(model) { this.model = model; }
+    getModel() { return this.model; }
+    resolveModelId(model) { return model; }
+    setEffort(effort) { this.effort = effort; }
+    getEffort() { return this.effort; }
+    setMode(mode) { this.permissionMode = normalizePermissionMode(mode).mode; }
+    getMode() { return normalizePermissionMode(this.permissionMode).mode; }
+    setPermissionGateway(gateway) { this.permissionGateway = gateway; }
+    setSendPrompt(fn) { this.sendPromptFn = fn; }
+    setPermissionContext(sessionId, context) { this.permissionContexts.set(sessionId, context); }
+    setCompactStartCallback(callback) { this.onCompactStart = callback; }
+    listModes() {
+        return [
+            { key: 'readonly', nameZh: '只读', description: '只读操作自动执行，写入直接拒绝', available: true },
+            { key: 'auto', nameZh: '自动', description: '常规操作自动执行，危险操作自动拒绝', available: true },
+            { key: 'request', nameZh: '审批', description: '默认能力自动执行，危险操作进入人工审批', available: true },
+            { key: 'bypass', nameZh: '放行', description: '普通审批清单自动执行，强危险操作仍需审批', available: true },
+        ];
+    }
+    async listModels() {
+        if (this.modelCache && Date.now() - this.modelCache.fetchedAt < MODEL_CACHE_TTL_MS)
+            return [...this.modelCache.ids];
+        const stale = this.modelCache?.ids;
+        try {
+            const signal = AbortSignal.timeout(MODEL_LIST_TIMEOUT_MS);
+            const response = await fetch(`${this.config.baseUrl.replace(/\/+$/, '')}/models`, {
+                headers: { authorization: `Bearer ${this.config.apiKey}` }, signal,
+            });
+            if (!response.ok)
+                throw new Error(`Failed to list ecagent models: HTTP ${response.status}`);
+            const payload = await response.json();
+            const ids = [...new Set((payload.data ?? [])
+                    .map(item => typeof item.id === 'string' ? item.id : '')
+                    .filter(id => id.startsWith('claude-') || (id.startsWith('gpt-') && !id.startsWith('gpt-image-'))))];
+            if (ids.length === 0)
+                throw new Error('Gateway returned no supported Claude or GPT models');
+            this.modelCache = { ids, fetchedAt: Date.now() };
+            return [...ids];
+        }
+        catch (error) {
+            if (stale && stale.length > 0)
+                return [...stale];
+            throw error;
+        }
+    }
+    registerStream(key, stream) { this.activeStreams.set(key, stream); }
+    cleanupStream(key) { this.activeStreams.delete(key); }
+    hasActiveStream(key) { return this.activeStreams.has(key) || !!this.runtimes.get(key)?.harness; }
+    updateSessionId(sessionId, agentSessionId) {
+        if (!agentSessionId) {
+            this.runtimes.delete(sessionId);
+        }
+        else {
+            const runtime = this.runtimes.get(sessionId);
+            if (runtime)
+                runtime.agentSessionId = agentSessionId;
+        }
+        void this.onSessionIdUpdate?.(sessionId, agentSessionId);
+    }
+    async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, _sessionManager, modelOverride, runtimeEnv = {}) {
+        const queue = new AsyncEventQueue();
+        this.activeStreams.set(sessionId, queue);
+        void this.executeRun(queue, {
+            sessionId, prompt, projectPath: path.resolve(projectPath), initialAgentSessionId, images,
+            systemPromptAppend, modelOverride, runtimeEnv,
+        });
+        return queue;
+    }
+    async executeRun(queue, request) {
+        const stats = { startedAt: Date.now(), text: '', numTurns: 0, usage: {}, modelCalls: [] };
+        let completeSent = false;
+        try {
+            await fs.promises.mkdir(request.projectPath, { recursive: true });
+            const previousRuntime = this.runtimes.get(request.sessionId);
+            const runtime = await this.getOrCreateRuntime(request.sessionId, request.projectPath, request.initialAgentSessionId);
+            if (!previousRuntime || request.initialAgentSessionId !== runtime.agentSessionId) {
+                queue.push({ type: 'session_id', sessionId: runtime.agentSessionId });
+            }
+            const modelId = request.modelOverride?.model || this.model;
+            const effort = request.modelOverride?.effortMode === 'model_default'
+                ? undefined
+                : request.modelOverride?.effort ?? this.effort;
+            const permissionMode = normalizePermissionMode(request.modelOverride?.permissionMode || this.permissionMode).mode;
+            const model = createModel(modelId, this.config.baseUrl);
+            const nodeEnv = new NodeExecutionEnv({ cwd: request.projectPath, shellEnv: { ...process.env, ...request.runtimeEnv, EVOLCORE_SESSION_ID: request.sessionId, EVOLCORE_HOME: resolveRoot() } });
+            const models = createModels();
+            const transport = createOpenAiTransport(this.config);
+            models.setProvider(createProvider({
+                id: PROVIDER_ID,
+                name: 'EvolCore Gateway',
+                baseUrl: this.config.baseUrl,
+                models: [model],
+                auth: { apiKey: {
+                        name: 'EvolCore gateway',
+                        login: async () => ({ type: 'api_key', key: this.config.apiKey }),
+                        resolve: async () => ({ auth: { apiKey: this.config.apiKey }, source: 'baseagents.ecagent.apiKey' }),
+                    } },
+                api: transport,
+            }));
+            const harness = new AgentHarness({
+                env: nodeEnv,
+                session: runtime.session,
+                models,
+                model,
+                thinkingLevel: normalizeThinkingLevel(effort),
+                tools: createTools(nodeEnv, request.projectPath, request.runtimeEnv),
+                systemPrompt: [DEFAULT_SYSTEM_PROMPT, request.systemPromptAppend].filter(Boolean).join('\n\n'),
+                streamOptions: {
+                    timeoutMs: this.config.timeoutMs,
+                    maxRetries: this.config.maxRetries,
+                    maxRetryDelayMs: this.config.maxRetryDelayMs,
+                },
+            });
+            runtime.harness = harness;
+            if (this.pendingInterrupts.delete(request.sessionId)) {
+                await harness.abort();
+                runtime.harness = undefined;
+                throw new Error('ecagent run interrupted');
+            }
+            harness.on('tool_call', event => this.authorizeTool(request.sessionId, request.projectPath, permissionMode, event.toolName, event.input));
+            const unsubscribe = harness.subscribe(event => this.mapHarnessEvent(queue, event, stats, model, effort));
+            queue.push({ type: 'state_changed', state: 'running' });
+            queue.push({ type: 'status', subtype: 'started', message: `ecagent is using ${modelId}` });
+            const ecImages = request.images?.map(image => ({
+                type: 'image', data: image.data, mimeType: image.mimeType || 'image/png',
+            }));
+            let result;
+            try {
+                result = await harness.prompt(request.prompt, { images: ecImages });
+            }
+            finally {
+                unsubscribe();
+                runtime.harness = undefined;
+            }
+            if (result.stopReason === 'error' || result.stopReason === 'aborted') {
+                const message = result.errorMessage || (result.stopReason === 'aborted' ? 'ecagent run interrupted' : 'ecagent run failed');
+                queue.push({ type: 'error', error: message, errorType: errorType(message) });
+            }
+            const title = await runtime.session.getSessionName();
+            queue.push({ type: 'state_changed', state: 'idle' });
+            queue.push({
+                type: 'complete',
+                result: stats.text,
+                isError: result.stopReason === 'error' || result.stopReason === 'aborted',
+                errors: result.errorMessage ? [result.errorMessage] : undefined,
+                terminalReason: result.stopReason === 'aborted' ? 'interrupted' : result.stopReason,
+                durationMs: Date.now() - stats.startedAt,
+                ttftMs: stats.firstTextAt ? stats.firstTextAt - stats.startedAt : undefined,
+                sessionTitle: title,
+                numTurns: stats.numTurns,
+                tokenUsage: stats.usage,
+                contextUsage: this.contextUsage(model, stats.usage, effort),
+                lastModelCall: stats.modelCalls.at(-1),
+                modelCalls: stats.modelCalls,
+            });
+            completeSent = true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const interrupted = message === 'ecagent run interrupted';
+            logger.error(`[EcagentRunner] run failed for session ${request.sessionId}:`, error);
+            queue.push({ type: 'error', error: message, errorType: errorType(message) });
+            queue.push({ type: 'state_changed', state: 'idle' });
+            queue.push({
+                type: 'complete', isError: true, errors: [message],
+                terminalReason: interrupted ? 'interrupted' : 'error', durationMs: Date.now() - stats.startedAt,
+            });
+            completeSent = true;
+        }
+        finally {
+            if (!completeSent)
+                queue.push({ type: 'complete', isError: true, terminalReason: 'error', durationMs: Date.now() - stats.startedAt });
+            this.pendingInterrupts.delete(request.sessionId);
+            this.activeStreams.delete(request.sessionId);
+            queue.end();
+        }
+    }
+    async getOrCreateRuntime(sessionId, projectPath, requestedId) {
+        const current = this.runtimes.get(sessionId);
+        const targetId = requestedId || current?.agentSessionId;
+        if (current && current.projectPath === projectPath && (!targetId || current.agentSessionId === targetId))
+            return current;
+        const env = new NodeExecutionEnv({ cwd: projectPath });
+        const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
+        let session;
+        if (targetId) {
+            const metadata = (await repo.list({ cwd: projectPath })).find(item => item.id === targetId);
+            if (!metadata) {
+                logger.warn(`[EcagentRunner] backing session ${targetId} was not found; creating a new session`);
+                session = await repo.create({ cwd: projectPath });
+            }
+            else
+                session = await repo.open(metadata);
+        }
+        else
+            session = await repo.create({ cwd: projectPath, id: sessionId });
+        const metadata = await session.getMetadata();
+        const runtime = { agentSessionId: metadata.id, projectPath, repo, session };
+        this.runtimes.set(sessionId, runtime);
+        if (metadata.id !== targetId) {
+            await this.onSessionIdUpdate?.(sessionId, metadata.id);
+            // The public event is emitted by the active query immediately after creation.
+        }
+        return runtime;
+    }
+    mapHarnessEvent(queue, event, stats, model, effort) {
+        if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
+            if (!stats.firstTextAt)
+                stats.firstTextAt = Date.now();
+            stats.text += event.assistantMessageEvent.delta;
+            queue.push({ type: 'text', text: event.assistantMessageEvent.delta, turn: stats.numTurns + 1 });
+            return;
+        }
+        if (event.type === 'tool_execution_start') {
+            queue.push({ type: 'tool_use', name: event.toolName, input: event.args, callId: event.toolCallId, turn: stats.numTurns + 1 });
+            return;
+        }
+        if (event.type === 'tool_execution_end') {
+            queue.push({
+                type: 'tool_result', name: event.toolName, result: extractToolResult(event.result),
+                isError: event.isError, error: event.isError ? extractToolResult(event.result) : undefined, callId: event.toolCallId,
+            });
+            return;
+        }
+        if (event.type === 'turn_end' && event.message.role === 'assistant') {
+            stats.numTurns++;
+            const usage = event.message.usage;
+            stats.usage.input_tokens = Number(stats.usage.input_tokens ?? 0) + usage.input;
+            stats.usage.output_tokens = Number(stats.usage.output_tokens ?? 0) + usage.output;
+            stats.usage.cache_read_input_tokens = Number(stats.usage.cache_read_input_tokens ?? 0) + usage.cacheRead;
+            stats.usage.cache_creation_input_tokens = Number(stats.usage.cache_creation_input_tokens ?? 0) + usage.cacheWrite;
+            const tokenUsage = {
+                input_tokens: usage.input, output_tokens: usage.output,
+                cache_read_input_tokens: usage.cacheRead, cache_creation_input_tokens: usage.cacheWrite,
+            };
+            stats.modelCalls.push({
+                call_index: stats.modelCalls.length,
+                model: event.message.model || model.id,
+                request_id: event.message.responseId,
+                tokenUsage,
+                contextUsage: this.contextUsage(model, tokenUsage, effort),
+            });
+        }
+    }
+    contextUsage(model, usage, effort) {
+        const totalTokens = Number(usage.input_tokens ?? 0) + Number(usage.output_tokens ?? 0)
+            + Number(usage.cache_read_input_tokens ?? 0) + Number(usage.cache_creation_input_tokens ?? 0);
+        return {
+            totalTokens, maxTokens: model.contextWindow,
+            percentage: model.contextWindow > 0 ? totalTokens / model.contextWindow * 100 : 0,
+            model: model.id, effort,
+        };
+    }
+    async authorizeTool(sessionId, projectPath, mode, toolName, input) {
+        const permissionContext = this.permissionContexts.get(sessionId);
+        const policy = permissionContext?.policyHook?.(toolName, input);
+        if (policy?.block)
+            return { block: true, reason: policy.reason || '当前会话策略拒绝此工具调用' };
+        const preflight = evaluateToolPreflight(toolName, input, {
+            sessionId,
+            channel: permissionContext?.channel,
+            userId: permissionContext?.userId,
+            role: permissionContext?.role,
+            permissionMode: mode,
+            projectPath,
+        });
+        if (preflight.behavior === 'deny')
+            return { block: true, reason: preflight.message };
+        if (preflight.behavior === 'allow')
+            return {};
+        const checkedInput = preflight.input;
+        if (mode === 'readonly') {
+            const decision = checkReadonly(toolName, checkedInput, projectPath, {
+                sessionId, channel: permissionContext?.channel, peerId: permissionContext?.userId, role: permissionContext?.role,
+            });
+            return decision.behavior === 'deny' ? { block: true, reason: decision.message } : {};
+        }
+        const dangerous = checkDangerousCommand(toolName, checkedInput);
+        if (mode === 'auto') {
+            return dangerous.isDangerous ? { block: true, reason: `危险操作已由 auto 模式拒绝：${dangerous.reason}` } : {};
+        }
+        const prompt = permissionContext?.sendPrompt ?? this.sendPromptFn;
+        const decision = await requestDangerousCommandPermission(this.permissionGateway, sessionId, toolName, checkedInput, prompt, permissionContext, `ecagent:${mode}`, mode);
+        return decision.matched && decision.decision === 'deny' ? { block: true, reason: '危险操作未获人工批准' } : {};
+    }
+    async interrupt(sessionKey) {
+        this.permissionGateway?.cancelAll(sessionKey, 'interrupted');
+        const harness = this.runtimes.get(sessionKey)?.harness;
+        if (harness) {
+            await harness.abort();
+            return;
+        }
+        if (this.activeStreams.has(sessionKey))
+            this.pendingInterrupts.add(sessionKey);
+    }
+    injectUserMessage(sessionId, text) {
+        const harness = this.runtimes.get(sessionId)?.harness;
+        if (harness)
+            void harness.steer(text).catch(error => logger.warn('[EcagentRunner] Failed to steer active run:', error));
+    }
+    async closeSession(sessionId) {
+        await this.interrupt(sessionId).catch(() => { });
+        this.runtimes.delete(sessionId);
+        this.activeStreams.delete(sessionId);
+        this.pendingInterrupts.delete(sessionId);
+        this.permissionContexts.delete(sessionId);
+    }
+    async clearSession(sessionId, agentSessionId, projectPath) {
+        try {
+            await this.interrupt(sessionId);
+            const env = new NodeExecutionEnv({ cwd: projectPath });
+            const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
+            const metadata = (await repo.list({ cwd: path.resolve(projectPath) })).find(item => item.id === agentSessionId);
+            if (metadata)
+                await repo.delete(metadata);
+            this.runtimes.delete(sessionId);
+            await this.onSessionIdUpdate?.(sessionId, '');
+            return !!metadata;
+        }
+        catch (error) {
+            logger.error('[EcagentRunner] clear failed:', error);
+            return false;
+        }
+    }
+    async compactSession(sessionId, agentSessionId, projectPath) {
+        try {
+            if (this.activeStreams.has(sessionId) || this.runtimes.get(sessionId)?.harness) {
+                logger.warn(`[EcagentRunner] compact skipped while session ${sessionId} is active`);
+                return false;
+            }
+            const cwd = path.resolve(projectPath);
+            const cached = this.runtimes.get(sessionId);
+            const runtime = cached?.agentSessionId === agentSessionId && cached.projectPath === cwd
+                ? cached
+                : await this.openExistingRuntime(agentSessionId, cwd);
+            this.onCompactStart?.(sessionId);
+            const model = createModel(this.model, this.config.baseUrl);
+            const env = new NodeExecutionEnv({ cwd: runtime.projectPath });
+            const models = createModels();
+            const transport = createOpenAiTransport(this.config);
+            models.setProvider(createProvider({
+                id: PROVIDER_ID, auth: { apiKey: { name: 'EvolCore gateway', login: async () => ({ type: 'api_key', key: this.config.apiKey }), resolve: async () => ({ auth: { apiKey: this.config.apiKey } }) } },
+                models: [model], api: transport,
+            }));
+            const harness = new AgentHarness({ env, session: runtime.session, models, model, thinkingLevel: normalizeThinkingLevel(this.effort), tools: [] });
+            runtime.harness = harness;
+            try {
+                await harness.compact();
+            }
+            finally {
+                runtime.harness = undefined;
+            }
+            this.runtimes.set(sessionId, runtime);
+            return true;
+        }
+        catch (error) {
+            logger.error('[EcagentRunner] compact failed:', error);
+            return false;
+        }
+    }
+    compact(sessionId, agentSessionId, projectPath) {
+        return this.compactSession(sessionId, agentSessionId, projectPath);
+    }
+    resolveSessionFile(agentSessionId, projectPath) {
+        const dir = path.join(this.sessionsRoot(), `--${path.resolve(projectPath).replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`);
+        try {
+            const file = fs.readdirSync(dir).find(name => name.endsWith(`_${agentSessionId}.jsonl`));
+            return file ? path.join(dir, file) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async forkSession(agentSessionId, projectPath, title) {
+        const cwd = path.resolve(projectPath);
+        const env = new NodeExecutionEnv({ cwd });
+        const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
+        const source = (await repo.list({ cwd })).find(item => item.id === agentSessionId);
+        if (!source)
+            throw new Error(`ecagent session not found: ${agentSessionId}`);
+        const fork = await repo.fork(source, { cwd });
+        if (title)
+            await fork.appendSessionName(title);
+        return (await fork.getMetadata()).id;
+    }
+    async getSessionMessages(agentSessionId, projectPath) {
+        const session = await this.openSession(agentSessionId, projectPath);
+        const entries = await session.getEntries();
+        return entries.flatMap(entry => {
+            if (entry.type !== 'message' || (entry.message.role !== 'user' && entry.message.role !== 'assistant'))
+                return [];
+            return [{
+                    type: entry.message.role,
+                    uuid: entry.id,
+                    session_id: agentSessionId,
+                    message: entry.message,
+                    parent_tool_use_id: null,
+                }];
+        });
+    }
+    async setSessionName(agentSessionId, name) {
+        try {
+            await (await this.openSession(agentSessionId)).appendSessionName(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async updateSessionMetadata(agentSessionId, metadata) {
+        const title = typeof metadata.title === 'string' ? metadata.title : typeof metadata.name === 'string' ? metadata.name : undefined;
+        return title ? this.setSessionName(agentSessionId, title) : true;
+    }
+    async rewindFiles() {
+        return { canRewind: false, error: 'ecagent does not support file rewind' };
+    }
+    async openSession(agentSessionId, projectPath) {
+        const cwd = path.resolve(projectPath || process.cwd());
+        const env = new NodeExecutionEnv({ cwd });
+        const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
+        const metadata = (await repo.list(projectPath ? { cwd } : {})).find(item => item.id === agentSessionId);
+        if (!metadata)
+            throw new Error(`ecagent session not found: ${agentSessionId}`);
+        return repo.open(metadata);
+    }
+    async openExistingRuntime(agentSessionId, projectPath) {
+        await fs.promises.mkdir(this.sessionsRoot(), { recursive: true });
+        const env = new NodeExecutionEnv({ cwd: projectPath });
+        const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
+        const metadata = (await repo.list({ cwd: projectPath })).find(item => item.id === agentSessionId);
+        if (!metadata)
+            throw new Error(`ecagent session not found: ${agentSessionId}`);
+        return {
+            agentSessionId,
+            projectPath,
+            repo,
+            session: await repo.open(metadata),
+        };
+    }
+    async dispose() {
+        await Promise.allSettled([...this.runtimes.keys()].map(sessionId => this.closeSession(sessionId)));
+        this.runtimes.clear();
+        this.activeStreams.clear();
+        this.pendingInterrupts.clear();
+    }
+}
+export class EcagentAgentPlugin {
+    name = 'ecagent';
+    isEnabled(agent) {
+        const override = agent.config.baseagents?.ecagent;
+        if (!override)
+            return false;
+        try {
+            resolveEcagentConfig({ agents: { ecagent: override } }, override);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    createAgent(agent, callbacks) {
+        const override = agent.config.baseagents?.ecagent;
+        if (!override)
+            return null;
+        const configured = { ...override, evolcoreAgentAid: agent.aid, evolcoreAgentConfig: agent.config };
+        const resolved = resolveEcagentConfig({ agents: { ecagent: configured } }, configured);
+        return { evolagentName: agent.name, baseagent: 'ecagent', agent: new EcagentRunner(resolved, callbacks) };
+    }
+}