aws-runtime-bridge 1.7.50 → 1.8.0

package/package/acode/dist/built-in-file-tools.js

@@ -1,8 +1,9 @@
-import { randomUUID } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
 function toDisplayPath(targetPath) {
-    return targetPath.replace(/\\/g, '/');
+    return targetPath.replace(/\\/g, "/");
 }
 async function pathExists(targetPath) {
     try {
@@ -28,20 +29,69 @@ function countOccurrences(content, search) {
 function readStringArg(args, names, label) {
     for (const name of names) {
         const value = args[name];
-        if (typeof value === 'string') {
+        if (typeof value === "string") {
             return value;
         }
     }
     throw new Error(`${label} is required`);
 }
+function readOptionalStringArg(args, names) {
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === "string" && value.trim()) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readOptionalPositiveIntegerArg(args, names, fallback) {
+    for (const name of names) {
+        const value = args[name];
+        const numeric = typeof value === "number"
+            ? value
+            : typeof value === "string"
+                ? Number(value)
+                : NaN;
+        if (Number.isFinite(numeric) && numeric > 0) {
+            return Math.floor(numeric);
+        }
+    }
+    return fallback;
+}
 function ensureInsideWorkspace(workspaceRoot, targetPath) {
     const resolvedTargetPath = path.resolve(targetPath);
     const relativePath = path.relative(workspaceRoot, resolvedTargetPath);
-    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
         throw new Error(`Target path is outside workspace: ${resolvedTargetPath}`);
     }
     return resolvedTargetPath;
 }
+async function resolveWorkspaceDirectory(workingDirectory, rawCwd) {
+    const requestedRoot = path.resolve(String(workingDirectory || "").trim());
+    const workspaceRoot = await fs.realpath(requestedRoot);
+    const workspaceStat = await fs.stat(workspaceRoot);
+    if (!workspaceStat.isDirectory()) {
+        throw new Error(`Workspace path is not a directory: ${requestedRoot}`);
+    }
+    if (!rawCwd?.trim()) {
+        return { workspaceRoot, cwd: workspaceRoot };
+    }
+    const requestedCwd = rawCwd.trim();
+    const candidatePath = path.isAbsolute(requestedCwd)
+        ? path.resolve(requestedCwd)
+        : path.resolve(requestedRoot, requestedCwd);
+    const requestedRelativePath = path.relative(requestedRoot, candidatePath);
+    if (requestedRelativePath.startsWith("..") ||
+        path.isAbsolute(requestedRelativePath)) {
+        throw new Error(`Command cwd is outside workspace: ${candidatePath}`);
+    }
+    const realCwd = ensureInsideWorkspace(workspaceRoot, await fs.realpath(candidatePath));
+    const cwdStat = await fs.stat(realCwd);
+    if (!cwdStat.isDirectory()) {
+        throw new Error(`Command cwd is not a directory: ${realCwd}`);
+    }
+    return { workspaceRoot, cwd: realCwd };
+}
 async function ensureWritableTarget(workspaceRoot, targetPath) {
     const realParentPath = await fs.realpath(path.dirname(targetPath));
     ensureInsideWorkspace(workspaceRoot, realParentPath);
@@ -52,8 +102,10 @@ async function ensureWritableTarget(workspaceRoot, targetPath) {
         }
     }
     catch (error) {
-        const errorCode = typeof error === 'object' && error !== null ? Reflect.get(error, 'code') : undefined;
-        if (errorCode !== 'ENOENT') {
+        const errorCode = typeof error === "object" && error !== null
+            ? Reflect.get(error, "code")
+            : undefined;
+        if (errorCode !== "ENOENT") {
             throw error;
         }
     }
@@ -63,7 +115,7 @@ async function ensureWritableTarget(workspaceRoot, targetPath) {
  * 主流程：同时校验请求路径与 realpath 工作区边界，防止绝对路径、`..` 与符号链接目录穿透。
  */
 async function resolveWorkspaceTarget(workingDirectory, rawFilePath) {
-    const requestedRoot = path.resolve(String(workingDirectory || '').trim());
+    const requestedRoot = path.resolve(String(workingDirectory || "").trim());
     const workspaceRoot = await fs.realpath(requestedRoot);
     const workspaceStat = await fs.stat(workspaceRoot);
     if (!workspaceStat.isDirectory()) {
@@ -71,13 +123,14 @@ async function resolveWorkspaceTarget(workingDirectory, rawFilePath) {
     }
     const normalizedFilePath = rawFilePath.trim();
     if (!normalizedFilePath) {
-        throw new Error('file_path is required');
+        throw new Error("file_path is required");
     }
     const requestedPath = path.isAbsolute(normalizedFilePath)
         ? path.resolve(normalizedFilePath)
         : path.resolve(requestedRoot, normalizedFilePath);
     const requestedRelativePath = path.relative(requestedRoot, requestedPath);
-    if (requestedRelativePath.startsWith('..') || path.isAbsolute(requestedRelativePath)) {
+    if (requestedRelativePath.startsWith("..") ||
+        path.isAbsolute(requestedRelativePath)) {
         throw new Error(`Target path is outside workspace: ${requestedPath}`);
     }
     return {
@@ -98,7 +151,7 @@ async function writeFileAtomically(workingDirectory, filePath, content) {
     await ensureWritableTarget(target.workspaceRoot, target.targetPath);
     const temporaryPath = path.join(parentPath, `.${path.basename(target.targetPath)}.${process.pid}.${randomUUID()}.tmp`);
     try {
-        await fs.writeFile(temporaryPath, content, 'utf-8');
+        await fs.writeFile(temporaryPath, content, "utf-8");
         await fs.rename(temporaryPath, target.targetPath);
     }
     catch (error) {
@@ -108,7 +161,7 @@ async function writeFileAtomically(workingDirectory, filePath, content) {
     return {
         workspaceRoot: target.workspaceRoot,
         targetPath: target.targetPath,
-        bytes: Buffer.byteLength(content, 'utf-8'),
+        bytes: Buffer.byteLength(content, "utf-8"),
         createdParentDirectory,
     };
 }
@@ -122,31 +175,239 @@ async function readFileInsideWorkspace(workingDirectory, filePath) {
     return {
         workspaceRoot: target.workspaceRoot,
         targetPath: realTargetPath,
-        content: await fs.readFile(realTargetPath, 'utf-8'),
+        content: await fs.readFile(realTargetPath, "utf-8"),
     };
 }
+const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
+const MAX_COMMAND_TIMEOUT_MS = 10 * 60_000;
+const DEFAULT_COMMAND_INACTIVITY_TIMEOUT_MS = 60_000;
+const MAX_COMMAND_INACTIVITY_TIMEOUT_MS = 10 * 60_000;
+const MAX_COMMAND_OUTPUT_BYTES = 128 * 1024;
+const COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT = 100;
+function padDatePart(value) {
+    return String(value).padStart(2, "0");
+}
+function countOutputLines(output) {
+    if (!output) {
+        return 0;
+    }
+    const normalized = output.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const withoutTrailingLineBreak = normalized.endsWith("\n")
+        ? normalized.slice(0, -1)
+        : normalized;
+    return withoutTrailingLineBreak
+        ? withoutTrailingLineBreak.split("\n").length
+        : 1;
+}
+function buildCommandOutputSpilloverPath(workspaceRoot, now = new Date()) {
+    const year = now.getFullYear();
+    const month = padDatePart(now.getMonth() + 1);
+    const day = padDatePart(now.getDate());
+    const hour = padDatePart(now.getHours());
+    const minute = padDatePart(now.getMinutes());
+    const timestamp = `${year}${month}${day}-${hour}${minute}${padDatePart(now.getSeconds())}-${String(now.getMilliseconds()).padStart(3, "0")}-${process.pid}-${randomUUID().slice(0, 8)}`;
+    return path.join(workspaceRoot, ".agentswork", "acode", "cmd-dist", `${year}-${month}-${day}`, hour, minute, `${timestamp}-cmd.out`);
+}
+async function writeCommandOutputSpilloverFile(workspaceRoot, content) {
+    const targetPath = buildCommandOutputSpilloverPath(workspaceRoot);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, content, "utf-8");
+    return targetPath;
+}
+function buildCommandOutputSpilloverContent(input) {
+    return [
+        `Command: ${input.commandText}`,
+        `CWD: ${input.cwd}`,
+        `Started: ${input.startedAt.toISOString()}`,
+        `Ended: ${input.endedAt.toISOString()}`,
+        `Exit code: ${input.exitCode ?? "null"}`,
+        `Signal: ${input.signal ?? "null"}`,
+        `Timed out: ${input.timedOut}`,
+        `Timed out by inactivity: ${input.inactivityTimedOut}`,
+        "",
+        "--- stdout ---",
+        input.stdout,
+        "",
+        "--- stderr ---",
+        input.stderr,
+    ].join("\n");
+}
+function formatCommandOutputSpilloverStdout(outputFilePath, outputLineCount) {
+    return [
+        `[ACode] 命令输出超过 ${COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT} 行（共 ${outputLineCount} 行），完整输出已写入: ${toDisplayPath(outputFilePath)}`,
+        "[ACode] Agent 可自行读取该文件，或在该文件中搜索需要的内容。",
+        "",
+    ].join("\n");
+}
+function truncateOutput(value) {
+    const bytes = Buffer.byteLength(value, "utf-8");
+    if (bytes <= MAX_COMMAND_OUTPUT_BYTES) {
+        return { text: value, truncated: false };
+    }
+    const buffer = Buffer.from(value, "utf-8");
+    return {
+        text: buffer.subarray(0, MAX_COMMAND_OUTPUT_BYTES).toString("utf-8") +
+            `\n...[truncated after ${MAX_COMMAND_OUTPUT_BYTES} bytes]`,
+        truncated: true,
+    };
+}
+function shellExecutable() {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            argsPrefix: ["/d", "/s", "/c"],
+        };
+    }
+    return { command: process.env.SHELL || "/bin/sh", argsPrefix: ["-lc"] };
+}
+function runShellCommand(commandText, workspaceRoot, cwd, timeoutMs, inactivityTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        const shell = shellExecutable();
+        const startedAt = new Date();
+        const child = spawn(shell.command, [...shell.argsPrefix, commandText], {
+            cwd,
+            env: process.env,
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let inactivityTimedOut = false;
+        let killEscalationTimer;
+        let inactivityTimer;
+        const escalateKill = () => {
+            killEscalationTimer = setTimeout(() => {
+                if (!child.killed) {
+                    child.kill("SIGKILL");
+                }
+            }, 1000);
+            killEscalationTimer.unref?.();
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            escalateKill();
+        }, timeoutMs);
+        timer.unref?.();
+        const resetInactivityTimer = () => {
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+            }
+            inactivityTimer = setTimeout(() => {
+                inactivityTimedOut = true;
+                timedOut = true;
+                child.kill("SIGTERM");
+                escalateKill();
+            }, inactivityTimeoutMs);
+            inactivityTimer.unref?.();
+        };
+        resetInactivityTimer();
+        child.stdout?.setEncoding("utf-8");
+        child.stderr?.setEncoding("utf-8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+            resetInactivityTimer();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+            resetInactivityTimer();
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+            }
+            if (killEscalationTimer) {
+                clearTimeout(killEscalationTimer);
+            }
+            reject(error);
+        });
+        child.on("close", async (exitCode, signal) => {
+            clearTimeout(timer);
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+            }
+            if (killEscalationTimer) {
+                clearTimeout(killEscalationTimer);
+            }
+            const endedAt = new Date();
+            const outputLineCount = countOutputLines(`${stdout}${stderr}`);
+            try {
+                if (outputLineCount > COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT) {
+                    const outputFilePath = await writeCommandOutputSpilloverFile(workspaceRoot, buildCommandOutputSpilloverContent({
+                        commandText,
+                        cwd,
+                        startedAt,
+                        endedAt,
+                        exitCode,
+                        signal,
+                        timedOut,
+                        inactivityTimedOut,
+                        stdout,
+                        stderr,
+                    }));
+                    resolve({
+                        exitCode,
+                        signal,
+                        stdout: formatCommandOutputSpilloverStdout(outputFilePath, outputLineCount),
+                        stderr: "",
+                        durationMs: endedAt.getTime() - startedAt.getTime(),
+                        timedOut,
+                        inactivityTimedOut,
+                        outputSpilled: true,
+                        outputFilePath: toDisplayPath(outputFilePath),
+                        outputLineCount,
+                    });
+                    return;
+                }
+                const truncatedStdout = truncateOutput(stdout);
+                const truncatedStderr = truncateOutput(stderr);
+                resolve({
+                    exitCode,
+                    signal,
+                    stdout: truncatedStdout.text,
+                    stderr: truncatedStderr.text,
+                    durationMs: endedAt.getTime() - startedAt.getTime(),
+                    timedOut,
+                    inactivityTimedOut,
+                    outputSpilled: false,
+                    outputLineCount,
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
 function writeFileTool(workingDirectory) {
     return {
-        kind: 'builtin',
-        toolName: 'write_file',
-        exposedName: 'write_file',
-        description: 'Create or overwrite a UTF-8 text file inside the current workspace. Parent directories are created automatically.',
+        kind: "builtin",
+        toolName: "write_file",
+        exposedName: "write_file",
+        description: "Create or overwrite a UTF-8 text file inside the current workspace. Parent directories are created automatically.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
-                file_path: { type: 'string', description: 'Workspace-relative file path to write.' },
-                content: { type: 'string', description: 'Complete UTF-8 file content.' },
+                file_path: {
+                    type: "string",
+                    description: "Workspace-relative file path to write.",
+                },
+                content: {
+                    type: "string",
+                    description: "Complete UTF-8 file content.",
+                },
             },
-            required: ['file_path', 'content'],
+            required: ["file_path", "content"],
             additionalProperties: false,
         },
         async execute(args) {
-            const filePath = readStringArg(args, ['file_path', 'filePath'], 'file_path');
-            const content = readStringArg(args, ['content'], 'content');
+            const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
+            const content = readStringArg(args, ["content"], "content");
             const result = await writeFileAtomically(workingDirectory, filePath, content);
             return {
                 ok: true,
-                tool: 'write_file',
+                tool: "write_file",
                 workspacePath: toDisplayPath(result.workspaceRoot),
                 filePath: toDisplayPath(result.targetPath),
                 bytes: result.bytes,
@@ -157,31 +418,37 @@ function writeFileTool(workingDirectory) {
 }
 function editFileTool(workingDirectory) {
     return {
-        kind: 'builtin',
-        toolName: 'edit_file',
-        exposedName: 'edit_file',
-        description: 'Replace exactly one occurrence of old_string with new_string in a UTF-8 workspace text file.',
+        kind: "builtin",
+        toolName: "edit_file",
+        exposedName: "edit_file",
+        description: "Replace exactly one occurrence of old_string with new_string in a UTF-8 workspace text file.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
-                file_path: { type: 'string', description: 'Workspace-relative file path to edit.' },
-                old_string: { type: 'string', description: 'Existing text to replace. Must occur exactly once.' },
-                new_string: { type: 'string', description: 'Replacement text.' },
+                file_path: {
+                    type: "string",
+                    description: "Workspace-relative file path to edit.",
+                },
+                old_string: {
+                    type: "string",
+                    description: "Existing text to replace. Must occur exactly once.",
+                },
+                new_string: { type: "string", description: "Replacement text." },
             },
-            required: ['file_path', 'old_string', 'new_string'],
+            required: ["file_path", "old_string", "new_string"],
             additionalProperties: false,
         },
         async execute(args) {
-            const filePath = readStringArg(args, ['file_path', 'filePath'], 'file_path');
-            const oldString = readStringArg(args, ['old_string', 'oldString'], 'old_string');
-            const newString = readStringArg(args, ['new_string', 'newString'], 'new_string');
+            const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
+            const oldString = readStringArg(args, ["old_string", "oldString"], "old_string");
+            const newString = readStringArg(args, ["new_string", "newString"], "new_string");
             if (!oldString) {
-                throw new Error('old_string must not be empty');
+                throw new Error("old_string must not be empty");
             }
             const current = await readFileInsideWorkspace(workingDirectory, filePath);
             const occurrences = countOccurrences(current.content, oldString);
             if (occurrences === 0) {
-                throw new Error('old_string was not found in file');
+                throw new Error("old_string was not found in file");
             }
             if (occurrences > 1) {
                 throw new Error(`old_string occurs ${occurrences} times; provide a unique match`);
@@ -190,7 +457,7 @@ function editFileTool(workingDirectory) {
             const result = await writeFileAtomically(workingDirectory, filePath, updatedContent);
             return {
                 ok: true,
-                tool: 'edit_file',
+                tool: "edit_file",
                 workspacePath: toDisplayPath(result.workspaceRoot),
                 filePath: toDisplayPath(result.targetPath),
                 replacements: 1,
@@ -201,24 +468,27 @@ function editFileTool(workingDirectory) {
 }
 function readFileTool(workingDirectory) {
     return {
-        kind: 'builtin',
-        toolName: 'read_file',
-        exposedName: 'read_file',
-        description: 'Read a UTF-8 text file inside the current workspace.',
+        kind: "builtin",
+        toolName: "read_file",
+        exposedName: "read_file",
+        description: "Read a UTF-8 text file inside the current workspace.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
-                file_path: { type: 'string', description: 'Workspace-relative file path to read.' },
+                file_path: {
+                    type: "string",
+                    description: "Workspace-relative file path to read.",
+                },
             },
-            required: ['file_path'],
+            required: ["file_path"],
             additionalProperties: false,
         },
         async execute(args) {
-            const filePath = readStringArg(args, ['file_path', 'filePath'], 'file_path');
+            const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
             const result = await readFileInsideWorkspace(workingDirectory, filePath);
             return {
                 ok: true,
-                tool: 'read_file',
+                tool: "read_file",
                 workspacePath: toDisplayPath(result.workspaceRoot),
                 filePath: toDisplayPath(result.targetPath),
                 content: result.content,
@@ -226,6 +496,74 @@ function readFileTool(workingDirectory) {
         },
     };
 }
+function bashTool(workingDirectory) {
+    return {
+        kind: "builtin",
+        toolName: "Bash",
+        exposedName: "Bash",
+        description: "Execute a shell command in the current workspace. Use for local diagnostics, builds, tests, and OS commands. The command runs with a bounded timeout and returns stdout, stderr, and exit code.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Shell command to execute." },
+                cwd: {
+                    type: "string",
+                    description: "Optional workspace-relative working directory. Defaults to the workspace root.",
+                },
+                timeout_ms: {
+                    type: "number",
+                    description: "Optional timeout in milliseconds. Defaults to 30000 and is capped at 600000.",
+                },
+                inactivity_timeout_ms: {
+                    type: "number",
+                    description: "Optional no-output timeout in milliseconds. Defaults to 60000 and is capped at 600000.",
+                },
+                description: {
+                    type: "string",
+                    description: "Optional short reason for running the command.",
+                },
+            },
+            required: ["command"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const command = readStringArg(args, ["command"], "command").trim();
+            if (!command) {
+                throw new Error("command must not be empty");
+            }
+            const requestedTimeoutMs = readOptionalPositiveIntegerArg(args, ["timeout_ms", "timeoutMs"], DEFAULT_COMMAND_TIMEOUT_MS);
+            const timeoutMs = Math.min(requestedTimeoutMs, MAX_COMMAND_TIMEOUT_MS);
+            const requestedInactivityTimeoutMs = readOptionalPositiveIntegerArg(args, ["inactivity_timeout_ms", "inactivityTimeoutMs"], DEFAULT_COMMAND_INACTIVITY_TIMEOUT_MS);
+            const inactivityTimeoutMs = Math.min(requestedInactivityTimeoutMs, MAX_COMMAND_INACTIVITY_TIMEOUT_MS);
+            const cwdArg = readOptionalStringArg(args, ["cwd"]);
+            const resolved = await resolveWorkspaceDirectory(workingDirectory, cwdArg);
+            const result = await runShellCommand(command, resolved.workspaceRoot, resolved.cwd, timeoutMs, inactivityTimeoutMs);
+            return {
+                ok: result.exitCode === 0 && !result.timedOut,
+                tool: "Bash",
+                command,
+                cwd: toDisplayPath(resolved.cwd),
+                exitCode: result.exitCode,
+                signal: result.signal,
+                timedOut: result.timedOut,
+                inactivityTimedOut: result.inactivityTimedOut,
+                timeoutMs,
+                inactivityTimeoutMs,
+                durationMs: result.durationMs,
+                outputSpilled: result.outputSpilled,
+                outputFilePath: result.outputFilePath,
+                outputLineCount: result.outputLineCount,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            };
+        },
+    };
+}
 export function createBuiltInFileTools(workingDirectory) {
-    return [readFileTool(workingDirectory), writeFileTool(workingDirectory), editFileTool(workingDirectory)];
+    return [
+        readFileTool(workingDirectory),
+        writeFileTool(workingDirectory),
+        editFileTool(workingDirectory),
+        bashTool(workingDirectory),
+    ];
 }

package/package/acode/dist/runtime.d.ts

@@ -1,10 +1,14 @@
-import { EventEmitter } from 'node:events';
-import type { ACodeRuntimeConfig } from './types.js';
+import { EventEmitter } from "node:events";
+import type { ACodeRuntimeConfig } from "./types.js";
 export declare class ACodeRuntime extends EventEmitter {
     private readonly config;
     private readonly hookBus;
     private state;
     private abortController;
+    private submitQueue;
+    private activeTurn;
+    private abortRequested;
+    private sessionCompleteEmitted;
     constructor(config: ACodeRuntimeConfig);
     private emitAcodeEvent;
     /**
@@ -19,14 +23,18 @@ export declare class ACodeRuntime extends EventEmitter {
      * MCP tool call 则执行工具并继续同一轮，最后输出 assistant 文本与 usage。
      */
     submit(message: string): Promise<void>;
-    /** 中止当前轮次；当前骨架无长任务，仅发出完成状态。 */
+    private executeSubmit;
+    /** 中止当前轮次；由执行轮次统一发出一个终态事件，避免 aborted/failed 双终态。 */
     abort(): Promise<void>;
     /** 终止 ACode 会话并发出 session_complete。 */
     stop(): Promise<void>;
     private resolveCommandDirs;
     private runModelTurn;
     private requestChatCompletion;
+    private readChatCompletionStream;
     private handleToolCalls;
+    private appendSyntheticMultimodalUserMessage;
+    private appendToolFailureResult;
     private connectMcpServers;
     private createMcpTransport;
     private disconnectMcpServers;

package/package/acode/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAa3C,OAAO,KAAK,EAOV,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AA6PpB,qBAAa,YAAa,SAAQ,YAAY;IAmBhC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAlBnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC,OAAO,CAAC,KAAK,CAYX;IAEF,OAAO,CAAC,eAAe,CAAgC;gBAE1B,MAAM,EAAE,kBAAkB;IAevD,OAAO,CAAC,cAAc;IAUtB;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE5B;;;;OAIG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+C5C,+BAA+B;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,uCAAuC;IACjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B,OAAO,CAAC,kBAAkB;YASZ,YAAY;YA6BZ,qBAAqB;YA+BrB,eAAe;YAiFf,iBAAiB;IA8B/B,OAAO,CAAC,kBAAkB;YAuBZ,oBAAoB;CAYnC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiB3C,OAAO,KAAK,EAOV,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AA44BpB,qBAAa,YAAa,SAAQ,YAAY;IAmChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAlCnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC,OAAO,CAAC,KAAK,CAoBX;IAEF,OAAO,CAAC,eAAe,CAAgC;IAEvD,OAAO,CAAC,WAAW,CAAoC;IAEvD,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,sBAAsB,CAAS;gBAEV,MAAM,EAAE,kBAAkB;IAevD,OAAO,CAAC,cAAc;IAatB;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwF5B;;;;OAIG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAM9B,aAAa;IA2E3B,oDAAoD;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B,uCAAuC;IACjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B3B,OAAO,CAAC,kBAAkB;YAaZ,YAAY;YA6DZ,qBAAqB;YAiHrB,wBAAwB;YA6ExB,eAAe;YAwJf,oCAAoC;IAkBlD,OAAO,CAAC,uBAAuB;YAuBjB,iBAAiB;IA2C/B,OAAO,CAAC,kBAAkB;YA2BZ,oBAAoB;CAiBnC"}