aws-runtime-bridge 1.7.50 → 1.8.0

package/package/acode/dist/runtime.js

@@ -1,26 +1,103 @@
-import { EventEmitter } from 'node:events';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { createBuiltInFileTools } from './built-in-file-tools.js';
-import { loadAcodeCommands } from './commands/commandLoader.js';
-import { ACodeCommandRegistry } from './commands/commandRegistry.js';
-import { loadAcodeConfig, loadAcodeSkills } from './config.js';
-import { ACodeHookBus, findDeniedHookResult } from './hooks/hookBus.js';
+import { EventEmitter } from "node:events";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createBuiltInFileTools, } from "./built-in-file-tools.js";
+import { loadAcodeCommands } from "./commands/commandLoader.js";
+import { ACodeCommandRegistry } from "./commands/commandRegistry.js";
+import { loadAcodeConfig, loadAcodeSkills } from "./config.js";
+import { ACodeHookBus, findDeniedHookResult } from "./hooks/hookBus.js";
 function nowIso() {
     return new Date().toISOString();
 }
 function isRecord(value) {
-    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isJsonObject(value) {
     return isRecord(value);
 }
 function normalizeText(value) {
-    const text = String(value ?? '').trim();
+    const text = String(value ?? "").trim();
     return text || undefined;
 }
+const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 60_000;
+const DEFAULT_PROVIDER_REQUEST_RETRY_COUNT = 2;
+const DEFAULT_PROVIDER_REQUEST_RETRY_DELAY_MS = 1000;
+const DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS = 60_000;
+const DEFAULT_MCP_POLLING_TOOL_CALL_TIMEOUT_MS = 30 * 60_000;
+const DEFAULT_RUNTIME_SHUTDOWN_TIMEOUT_MS = 10_000;
+const MAX_INLINE_IMAGE_BYTES = 10 * 1024 * 1024;
+async function withTimeout(operation, timeoutMs, label, onTimeout) {
+    if (timeoutMs <= 0) {
+        return await operation;
+    }
+    let timeout;
+    try {
+        return await new Promise((resolve, reject) => {
+            timeout = setTimeout(() => {
+                onTimeout?.();
+                reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            operation.then(resolve, reject);
+        });
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function runBestEffort(label, operation, onError, timeoutMs = DEFAULT_RUNTIME_SHUTDOWN_TIMEOUT_MS) {
+    try {
+        await withTimeout(operation, timeoutMs, label);
+    }
+    catch (error) {
+        onError(error instanceof Error ? error.message : String(error));
+    }
+}
+function normalizeNonNegativeInteger(value, fallback) {
+    if (value === 0 || value === "0") {
+        return 0;
+    }
+    const numeric = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(numeric) && numeric > 0
+        ? Math.floor(numeric)
+        : fallback;
+}
+function normalizePositiveInteger(value, fallback) {
+    const numeric = normalizeNonNegativeInteger(value, fallback);
+    return numeric > 0 ? numeric : fallback;
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isMcpPollingToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    return (normalized === "poll_message" ||
+        normalized === "get_message" ||
+        normalized.includes("poll_message"));
+}
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+function modelSupportsImageInput(model, defaultProvider, providerOptions) {
+    if (isBoolean(providerOptions?.supportsImageInput)) {
+        return providerOptions.supportsImageInput;
+    }
+    const models = isRecord(defaultProvider) ? defaultProvider.models : undefined;
+    const modelConfig = isRecord(models) ? models[model] : undefined;
+    if (!isRecord(modelConfig)) {
+        return false;
+    }
+    const modalities = modelConfig.modalities;
+    if (!isRecord(modalities) || !Array.isArray(modalities.input)) {
+        return false;
+    }
+    return modalities.input.some((item) => String(item || "")
+        .trim()
+        .toLowerCase() === "image");
+}
 /**
  * 解析 ACode 当前会话模型：优先显式启动参数，其次兼容 cc-switch 写入的
  * OpenCode-style `provider.default.model`，最后回落到旧版 top-level model。
@@ -28,41 +105,263 @@ function normalizeText(value) {
 function resolveProviderConfig(config, acodeConfig) {
     const defaultProvider = acodeConfig.provider?.default;
     const providerOptions = defaultProvider?.options;
+    const model = config.model ||
+        defaultProvider?.model ||
+        acodeConfig.model ||
+        "acode-default";
     return {
-        model: config.model || defaultProvider?.model || acodeConfig.model || 'acode-default',
+        model,
         baseURL: normalizeText(providerOptions?.baseURL || providerOptions?.baseUrl),
         apiKey: normalizeText(providerOptions?.apiKey),
         systemPrompt: config.systemPrompt || acodeConfig.systemPrompt,
+        stream: providerOptions?.stream !== false,
+        requestTimeoutMs: normalizeNonNegativeInteger(providerOptions?.requestTimeoutMs ?? providerOptions?.timeoutMs, DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS),
+        requestRetryCount: normalizeNonNegativeInteger(providerOptions?.requestRetryCount, DEFAULT_PROVIDER_REQUEST_RETRY_COUNT),
+        mcpToolTimeoutMs: normalizePositiveInteger(providerOptions?.mcpToolTimeoutMs, DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS),
+        mcpPollingToolTimeoutMs: normalizePositiveInteger(providerOptions?.mcpPollingToolTimeoutMs, DEFAULT_MCP_POLLING_TOOL_CALL_TIMEOUT_MS),
+        supportsImageInput: modelSupportsImageInput(model, defaultProvider, providerOptions),
     };
 }
+function appendTextPart(parts, text) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized) {
+        parts.push({ type: "text", text: normalized });
+    }
+}
+function toDataImageUrl(mediaType, rawBase64) {
+    const trimmed = rawBase64.trim();
+    if (/^data:image\/[a-z0-9.+-]+;base64,/i.test(trimmed)) {
+        return trimmed;
+    }
+    return `data:${mediaType || "image/png"};base64,${trimmed}`;
+}
+function isDataImageUrl(url) {
+    return /^data:image\/[a-z0-9.+-]+;base64,/i.test(url.trim());
+}
+function assertFetchableImageUrl(url) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        throw new Error(`ACode image URL is invalid: ${url}`);
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+        throw new Error(`ACode image URL protocol is not supported: ${parsedUrl.protocol}`);
+    }
+}
+async function responseToBase64(response) {
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > MAX_INLINE_IMAGE_BYTES) {
+        throw new Error(`ACode image is too large to inline: ${arrayBuffer.byteLength} bytes exceeds ${MAX_INLINE_IMAGE_BYTES} bytes`);
+    }
+    return Buffer.from(arrayBuffer).toString("base64");
+}
+async function materializeImageUrl(url) {
+    const trimmedUrl = url.trim();
+    if (isDataImageUrl(trimmedUrl)) {
+        return trimmedUrl;
+    }
+    assertFetchableImageUrl(trimmedUrl);
+    const response = await fetch(trimmedUrl);
+    if (!response.ok) {
+        throw new Error(`ACode image fetch failed: ${response.status} ${await response.text()}`);
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const mediaType = contentType.split(";")[0]?.trim().toLowerCase() || "";
+    if (!mediaType.startsWith("image/")) {
+        throw new Error(`ACode image URL did not return an image content type: ${contentType || "unknown"}`);
+    }
+    return `data:${mediaType};base64,${await responseToBase64(response)}`;
+}
+function normalizeImageAttachmentUrl(attachment) {
+    const base64 = normalizeText(attachment.base64Data ?? attachment.base64 ?? attachment.data);
+    if (base64) {
+        return toDataImageUrl(normalizeText(attachment.mediaType ?? attachment.mimeType) || "image/png", base64);
+    }
+    return normalizeText(attachment.url ?? attachment.serverUrl);
+}
+function fileAttachmentText(name, url, mediaType, size) {
+    const details = [
+        name ? `name=${name}` : undefined,
+        url ? `url=${url}` : undefined,
+        mediaType ? `mediaType=${mediaType}` : undefined,
+        size ? `size=${size}` : undefined,
+    ].filter((item) => Boolean(item));
+    return `[Attached file: ${details.join(", ")}]`;
+}
+function parseMarkerAttachmentMessage(message) {
+    const markerRegex = /\[(图片|文件)\s*:\s*([^\]\n]*?)\s*\]/gi;
+    const parts = [];
+    let hasImages = false;
+    let lastIndex = 0;
+    let match = markerRegex.exec(message);
+    while (match !== null) {
+        appendTextPart(parts, message.slice(lastIndex, match.index));
+        const markerType = match[1];
+        const markerValue = (match[2] || "").trim();
+        if (markerType === "图片" && markerValue) {
+            parts.push({ type: "image_url", image_url: { url: markerValue } });
+            hasImages = true;
+        }
+        else if (markerType === "文件" && markerValue) {
+            const [name = "", url = "", mediaType = "", size = ""] = markerValue
+                .split("|")
+                .map((item) => item.trim());
+            appendTextPart(parts, fileAttachmentText(name, url, mediaType, size));
+        }
+        else {
+            appendTextPart(parts, match[0]);
+        }
+        lastIndex = match.index + match[0].length;
+        match = markerRegex.exec(message);
+    }
+    if (parts.length === 0) {
+        return { content: message, hasImages: false };
+    }
+    appendTextPart(parts, message.slice(lastIndex));
+    return { content: parts, hasImages };
+}
+function appendPolledMessagesContent(parts, parsed) {
+    let hasImages = false;
+    const messageGroups = [parsed.directMessages, parsed.groupMessages];
+    for (const group of messageGroups) {
+        if (!Array.isArray(group)) {
+            continue;
+        }
+        for (const item of group) {
+            if (!isRecord(item)) {
+                continue;
+            }
+            const content = normalizeText(item.content);
+            if (!content) {
+                continue;
+            }
+            const senderName = normalizeText(item.senderName);
+            appendTextPart(parts, senderName ? `Message from ${senderName}:` : "Message:");
+            const parsedContent = parseAttachmentMessage(content);
+            if (Array.isArray(parsedContent.content)) {
+                parts.push(...parsedContent.content);
+            }
+            else {
+                appendTextPart(parts, parsedContent.content);
+            }
+            hasImages = hasImages || parsedContent.hasImages;
+        }
+    }
+    return hasImages;
+}
+function parseJsonAttachmentMessage(message) {
+    let parsed;
+    try {
+        parsed = JSON.parse(message);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(parsed)) {
+        return undefined;
+    }
+    const parts = [];
+    let hasImages = appendPolledMessagesContent(parts, parsed);
+    const text = normalizeText(parsed.text) || "";
+    const rawAttachments = Array.isArray(parsed.attachments)
+        ? parsed.attachments
+        : [];
+    appendTextPart(parts, text);
+    for (const item of rawAttachments) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        const attachment = item;
+        const kind = String(attachment.type ?? attachment.kind ?? "").toLowerCase();
+        if (kind === "image") {
+            const imageUrl = normalizeImageAttachmentUrl(attachment);
+            if (imageUrl) {
+                parts.push({ type: "image_url", image_url: { url: imageUrl } });
+                hasImages = true;
+            }
+            continue;
+        }
+        const fileUrl = normalizeText(attachment.url ?? attachment.serverUrl) || "";
+        appendTextPart(parts, fileAttachmentText(normalizeText(attachment.name) || "", fileUrl, normalizeText(attachment.mediaType ?? attachment.mimeType) || "", normalizeText(attachment.size) || ""));
+    }
+    if (parts.length === 0) {
+        return { content: message, hasImages: false };
+    }
+    return { content: parts, hasImages };
+}
+function parseAttachmentMessage(message) {
+    return (parseJsonAttachmentMessage(message) ?? parseMarkerAttachmentMessage(message));
+}
+async function materializeImageContent(content) {
+    if (!Array.isArray(content)) {
+        return content;
+    }
+    const materializedParts = [];
+    for (const part of content) {
+        if (part.type === "text") {
+            materializedParts.push(part);
+            continue;
+        }
+        materializedParts.push({
+            type: "image_url",
+            image_url: { url: await materializeImageUrl(part.image_url.url) },
+        });
+    }
+    return materializedParts;
+}
+function contentPreview(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((part) => (part.type === "text" ? part.text : "[Image]"))
+        .join(" ")
+        .trim();
+}
 /**
  * 解析 ACode 工具权限配置。
  * 主流程：运行时配置优先 -> `.acode/config.json` 次之 -> 兼容旧式 allowedTools/deniedTools 字段。
  */
 function resolvePermissionConfig(config, acodeConfig) {
     const configured = config.permissions ?? acodeConfig.permissions ?? {};
-    const legacyAllow = config.permissions ? [] : acodeConfig.allowedTools ?? [];
-    const legacyDeny = config.permissions ? [] : acodeConfig.deniedTools ?? [];
+    const legacyAllow = config.permissions
+        ? []
+        : (acodeConfig.allowedTools ?? []);
+    const legacyDeny = config.permissions ? [] : (acodeConfig.deniedTools ?? []);
     return {
-        mode: configured.mode ?? 'default',
-        allow: [...(configured.allow ?? []), ...legacyAllow].map((rule) => rule.trim()).filter(Boolean),
-        deny: [...(configured.deny ?? []), ...legacyDeny].map((rule) => rule.trim()).filter(Boolean),
+        mode: configured.mode ?? "default",
+        allow: [...(configured.allow ?? []), ...legacyAllow]
+            .map((rule) => rule.trim())
+            .filter(Boolean),
+        deny: [...(configured.deny ?? []), ...legacyDeny]
+            .map((rule) => rule.trim())
+            .filter(Boolean),
     };
 }
 function wildcardMatches(pattern, value) {
-    if (pattern === '*') {
+    if (pattern === "*") {
         return true;
     }
-    if (pattern.endsWith('*')) {
+    if (pattern.endsWith("*")) {
         return value.startsWith(pattern.slice(0, -1));
     }
     return pattern === value;
 }
 function toolPermissionNames(tool) {
-    if (tool.kind === 'builtin') {
+    if (tool.kind === "builtin") {
         return [tool.exposedName, tool.toolName, `builtin.${tool.toolName}`];
     }
-    return [tool.exposedName, tool.toolName, `${tool.serverName}.${tool.toolName}`, `mcp.${tool.serverName}.${tool.toolName}`];
+    return [
+        tool.exposedName,
+        tool.toolName,
+        `${tool.serverName}.${tool.toolName}`,
+        `mcp.${tool.serverName}.${tool.toolName}`,
+    ];
 }
 function matchesToolRule(rule, tool) {
     return toolPermissionNames(tool).some((name) => wildcardMatches(rule, name));
@@ -73,7 +372,7 @@ function assertToolAllowedByRules(tool, rules, message) {
     }
 }
 function assertToolPermission(tool, permissions, commandAllowedTools) {
-    if (permissions.mode === 'bypassPermissions') {
+    if (permissions.mode === "bypassPermissions") {
         return;
     }
     if (permissions.deny.some((rule) => matchesToolRule(rule, tool))) {
@@ -92,12 +391,33 @@ function isToolAllowed(tool, permissions, commandAllowedTools) {
     }
 }
 function normalizeChatCompletionsUrl(baseURL) {
-    const trimmed = baseURL.replace(/\/+$/g, '');
+    const trimmed = baseURL.replace(/\/+$/g, "");
     if (/\/chat\/completions$/i.test(trimmed)) {
         return trimmed;
     }
     return `${trimmed}/chat/completions`;
 }
+function summarizeProviderUrl(baseURL) {
+    try {
+        const url = new URL(baseURL);
+        url.search = "";
+        url.hash = "";
+        const normalizedUrl = new URL(normalizeChatCompletionsUrl(url.toString()));
+        return `${normalizedUrl.origin}${normalizedUrl.pathname}`;
+    }
+    catch {
+        return normalizeChatCompletionsUrl(baseURL).replace(/([?&](?:api[_-]?key|token|authorization)=)[^&]+/gi, "$1[redacted]");
+    }
+}
+function summarizeLastUserMessage(messages) {
+    const lastUserMessage = [...messages]
+        .reverse()
+        .find((message) => message.role === "user");
+    const content = contentPreview(lastUserMessage?.content ?? null).trim();
+    if (!content)
+        return undefined;
+    return content.length > 300 ? `${content.slice(0, 300)}...` : content;
+}
 function coerceArguments(rawArguments) {
     try {
         const parsed = JSON.parse(rawArguments);
@@ -107,56 +427,132 @@ function coerceArguments(rawArguments) {
         return {};
     }
 }
+function getBuiltInToolTimeoutMs(tool, args, fallbackTimeoutMs) {
+    if (tool.toolName !== "Bash") {
+        return fallbackTimeoutMs;
+    }
+    const rawTimeout = args.timeout_ms ?? args.timeoutMs;
+    const numericTimeout = typeof rawTimeout === "number"
+        ? rawTimeout
+        : typeof rawTimeout === "string"
+            ? Number(rawTimeout)
+            : NaN;
+    if (!Number.isFinite(numericTimeout) || numericTimeout <= 0) {
+        return fallbackTimeoutMs;
+    }
+    return Math.min(Math.floor(numericTimeout), 10 * 60_000) + 2000;
+}
 function createFallbackResponse(message, state) {
     const trimmed = message.trim();
-    return `ACode 已接收任务。当前已加载 ${state.configMcpCount} 个 MCP 配置、${state.exposedTools.length} 个 MCP Tool 与 ${state.skills.length} 个 Skill。${trimmed ? `输入摘要：${trimmed.slice(0, 200)}` : ''}`;
+    return `ACode 已接收任务。当前已加载 ${state.configMcpCount} 个 MCP 配置、${state.exposedTools.length} 个 MCP Tool 与 ${state.skills.length} 个 Skill。${trimmed ? `输入摘要：${trimmed.slice(0, 200)}` : ""}`;
 }
 function toToolResultText(result) {
     if (!isRecord(result)) {
-        return String(result ?? '');
+        return String(result ?? "");
     }
     const content = result.content;
     if (Array.isArray(content)) {
         const parts = content
             .map((item) => {
             if (!isRecord(item)) {
-                return '';
+                return "";
             }
-            if (typeof item.text === 'string') {
+            if (typeof item.text === "string") {
                 return item.text;
             }
             return JSON.stringify(item);
         })
             .filter(Boolean);
         if (parts.length > 0) {
-            return parts.join('\n');
+            return parts.join("\n");
         }
     }
     return JSON.stringify(result);
 }
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRetryableProviderRequestError(error) {
+    const message = getErrorMessage(error).toLowerCase();
+    return (message.includes("fetch failed") ||
+        message.includes("timed out") ||
+        message.includes("econnreset") ||
+        message.includes("econnrefused") ||
+        message.includes("etimedout") ||
+        message.includes("enotfound") ||
+        message.includes("502") ||
+        message.includes("503") ||
+        message.includes("504"));
+}
+function getErrorType(error) {
+    if (typeof error === "object" && error !== null) {
+        const code = Reflect.get(error, "code");
+        if (typeof code === "string" && code) {
+            return code;
+        }
+        const name = Reflect.get(error, "name");
+        if (typeof name === "string" && name) {
+            return name;
+        }
+    }
+    return "tool_error";
+}
+function toToolErrorResultText(tool, error) {
+    return JSON.stringify({
+        ok: false,
+        tool: tool.exposedName,
+        error: {
+            type: getErrorType(error),
+            message: getErrorMessage(error),
+        },
+    });
+}
+function summarizeToolArguments(toolArguments) {
+    const serialized = JSON.stringify(toolArguments);
+    return serialized.length > 500 ? `${serialized.slice(0, 500)}…` : serialized;
+}
+function extractReasoningText(delta) {
+    const candidates = [
+        delta?.reasoning_content,
+        delta?.reasoning_text,
+        delta?.reasoning,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate) {
+            return candidate;
+        }
+        if (isRecord(candidate)) {
+            const text = candidate.text ?? candidate.content;
+            if (typeof text === "string" && text) {
+                return text;
+            }
+        }
+    }
+    return "";
+}
 function buildSkillPrompt(skills) {
     if (skills.length === 0) {
-        return '';
+        return "";
     }
     return [
-        'Available skills:',
-        ...skills.map((skill) => `- ${skill.name}${skill.description ? `: ${skill.description}` : ''}`),
-        'Use these skills as guidance when they match the user task.',
-    ].join('\n');
+        "Available skills:",
+        ...skills.map((skill) => `- ${skill.name}${skill.description ? `: ${skill.description}` : ""}`),
+        "Use these skills as guidance when they match the user task.",
+    ].join("\n");
 }
 function buildCommandPrompt(commands) {
     if (commands.length === 0) {
-        return '';
+        return "";
     }
     return [
-        'Available slash commands:',
-        ...commands.map((command) => `- /${command.name}${command.description ? `: ${command.description}` : ''}`),
-        'When the user invokes a slash command, ACode expands it before model execution.',
-    ].join('\n');
+        "Available slash commands:",
+        ...commands.map((command) => `- /${command.name}${command.description ? `: ${command.description}` : ""}`),
+        "When the user invokes a slash command, ACode expands it before model execution.",
+    ].join("\n");
 }
 function toOpenAiTools(tools) {
     return tools.map((tool) => ({
-        type: 'function',
+        type: "function",
         function: {
             name: tool.exposedName,
             description: tool.description || tool.toolName,
@@ -165,16 +561,49 @@ function toOpenAiTools(tools) {
     }));
 }
 function normalizeToolName(serverName, toolName) {
-    const normalized = `${serverName}__${toolName}`.replace(/[^a-zA-Z0-9_-]/g, '_');
-    return normalized.slice(0, 64) || 'mcp_tool';
+    const normalized = `${serverName}__${toolName}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return normalized.slice(0, 64) || "mcp_tool";
 }
 function buildRequestHeaders(provider) {
-    const headers = { 'Content-Type': 'application/json' };
+    const headers = {
+        "Content-Type": "application/json",
+    };
     if (provider.apiKey) {
         headers.Authorization = `Bearer ${provider.apiKey}`;
     }
     return headers;
 }
+function parseSseDataLines(chunk) {
+    return chunk
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trim())
+        .filter(Boolean);
+}
+function updateToolCallAccumulator(accumulators, delta) {
+    const index = Number.isFinite(delta.index) ? Number(delta.index) : 0;
+    const current = accumulators.get(index) ?? {
+        id: delta.id || `call-${index}`,
+        type: "function",
+        function: { name: "", arguments: "" },
+    };
+    if (delta.id) {
+        current.id = delta.id;
+    }
+    if (delta.function?.name) {
+        current.function.name += delta.function.name;
+    }
+    if (delta.function?.arguments) {
+        current.function.arguments += delta.function.arguments;
+    }
+    accumulators.set(index, current);
+}
+function toAccumulatedToolCalls(accumulators) {
+    return [...accumulators.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([, value]) => value)
+        .filter((toolCall) => toolCall.function.name.trim().length > 0);
+}
 export class ACodeRuntime extends EventEmitter {
     constructor(config) {
         super();
@@ -184,8 +613,16 @@ export class ACodeRuntime extends EventEmitter {
             terminated: false,
             configMcpCount: 0,
             skills: [],
-            provider: { model: 'acode-default' },
-            permissions: { mode: 'default', allow: [], deny: [] },
+            provider: {
+                model: "acode-default",
+                stream: false,
+                requestTimeoutMs: DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
+                requestRetryCount: DEFAULT_PROVIDER_REQUEST_RETRY_COUNT,
+                mcpToolTimeoutMs: DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS,
+                mcpPollingToolTimeoutMs: DEFAULT_MCP_POLLING_TOOL_CALL_TIMEOUT_MS,
+                supportsImageInput: false,
+            },
+            permissions: { mode: "default", allow: [], deny: [] },
             mcpConnections: [],
             exposedTools: [],
             commands: [],
@@ -193,10 +630,14 @@ export class ACodeRuntime extends EventEmitter {
             conversation: [],
         };
         this.abortController = null;
+        this.submitQueue = Promise.resolve();
+        this.activeTurn = false;
+        this.abortRequested = false;
+        this.sessionCompleteEmitted = false;
         this.hookBus = new ACodeHookBus({
             sessionId: config.sessionId,
             onError: (event, error) => {
-                this.emitAcodeEvent('error', {
+                this.emitAcodeEvent("error", {
                     message: `ACode hook failed: ${event.name}: ${error instanceof Error ? error.message : String(error)}`,
                 });
             },
@@ -212,7 +653,7 @@ export class ACodeRuntime extends EventEmitter {
             timestamp: nowIso(),
             data,
         };
-        this.emit('event', event);
+        this.emit("event", event);
     }
     /**
      * 启动 ACode headless 会话。
@@ -224,9 +665,12 @@ export class ACodeRuntime extends EventEmitter {
         const skills = await loadAcodeSkills(this.config.skillsDir);
         const provider = resolveProviderConfig(this.config, acodeConfig);
         const permissions = resolvePermissionConfig(this.config, acodeConfig);
-        const mcpConnections = await this.connectMcpServers(acodeConfig.mcpServers ?? {});
+        const mcpConnections = await this.connectMcpServers(acodeConfig.mcpServers ?? {}, provider.mcpToolTimeoutMs);
         const builtInTools = createBuiltInFileTools(this.config.workingDirectory);
-        const exposedTools = [...builtInTools, ...mcpConnections.flatMap((connection) => connection.tools)];
+        const exposedTools = [
+            ...builtInTools,
+            ...mcpConnections.flatMap((connection) => connection.tools),
+        ];
         const commandDirs = this.resolveCommandDirs(acodeConfig);
         const commands = await loadAcodeCommands(commandDirs);
         const commandRegistry = new ACodeCommandRegistry(commands);
@@ -235,7 +679,7 @@ export class ACodeRuntime extends EventEmitter {
         const systemPrompt = [provider.systemPrompt, skillPrompt, commandPrompt]
             .map((item) => item?.trim())
             .filter((item) => Boolean(item))
-            .join('\n\n');
+            .join("\n\n");
         this.state = {
             started: true,
             terminated: false,
@@ -247,19 +691,21 @@ export class ACodeRuntime extends EventEmitter {
             exposedTools,
             commands,
             commandRegistry,
-            conversation: systemPrompt ? [{ role: 'system', content: systemPrompt }] : [],
+            conversation: systemPrompt
+                ? [{ role: "system", content: systemPrompt }]
+                : [],
         };
-        await this.hookBus.dispatch('SessionStart', {
+        await this.hookBus.dispatch("SessionStart", {
             workingDirectory: this.config.workingDirectory,
             model: provider.model,
             commandCount: commands.length,
         });
-        this.emitAcodeEvent('session_started', {
+        this.emitAcodeEvent("session_started", {
             workingDirectory: this.config.workingDirectory,
             model: provider.model,
             commandCount: commands.length,
         });
-        this.emitAcodeEvent('mcp_status', {
+        this.emitAcodeEvent("mcp_status", {
             configPath: this.config.configPath,
             installedCount: this.state.configMcpCount,
             servers: Object.keys(acodeConfig.mcpServers ?? {}),
@@ -271,19 +717,27 @@ export class ACodeRuntime extends EventEmitter {
             deniedToolRules: permissions.deny,
             tools: exposedTools.map((tool) => ({
                 name: tool.exposedName,
-                source: tool.kind === 'mcp' ? `${tool.serverName}.${tool.toolName}` : `builtin.${tool.toolName}`,
+                source: tool.kind === "mcp"
+                    ? `${tool.serverName}.${tool.toolName}`
+                    : `builtin.${tool.toolName}`,
             })),
         });
-        this.emitAcodeEvent('skill_status', {
+        this.emitAcodeEvent("skill_status", {
             skillsDir: this.config.skillsDir,
             installedCount: skills.length,
-            skills: skills.map((skill) => ({ name: skill.name, description: skill.description })),
+            skills: skills.map((skill) => ({
+                name: skill.name,
+                description: skill.description,
+            })),
         });
-        this.emitAcodeEvent('command_status', {
-            action: 'commands_loaded',
+        this.emitAcodeEvent("command_status", {
+            action: "commands_loaded",
             installedCommandCount: commands.length,
             commandDirs,
-            commands: commands.map((command) => ({ name: command.name, description: command.description })),
+            commands: commands.map((command) => ({
+                name: command.name,
+                description: command.description,
+            })),
         });
         if (this.config.initialPrompt) {
             await this.submit(this.config.initialPrompt);
@@ -295,68 +749,107 @@ export class ACodeRuntime extends EventEmitter {
      * MCP tool call 则执行工具并继续同一轮，最后输出 assistant 文本与 usage。
      */
     async submit(message) {
+        const queued = this.submitQueue.then(() => this.executeSubmit(message));
+        this.submitQueue = queued.catch(() => undefined);
+        return queued;
+    }
+    async executeSubmit(message) {
         if (!this.state.started || this.state.terminated) {
-            throw new Error('ACode runtime is not active');
+            throw new Error("ACode runtime is not active");
         }
+        this.activeTurn = true;
+        this.abortRequested = false;
         const originalPrompt = message.trim();
-        const promptHookResults = await this.hookBus.dispatch('UserPromptSubmit', { prompt: originalPrompt });
-        const promptDeny = findDeniedHookResult(promptHookResults);
-        if (promptDeny) {
-            this.emitAcodeEvent('error', { message: promptDeny.message || 'ACode prompt was denied by hook' });
-            this.emitAcodeEvent('turn_complete', { failed: true });
-            return;
-        }
-        const expandedCommand = this.state.commandRegistry.expand(originalPrompt);
-        const trimmed = expandedCommand?.prompt.trim() || originalPrompt;
-        const commandAllowedTools = expandedCommand?.command.allowedTools;
-        if (expandedCommand) {
-            this.emitAcodeEvent('command_status', {
-                action: 'slash_command',
-                command: expandedCommand.command.name,
-                arguments: expandedCommand.argumentsText,
-                sourcePath: expandedCommand.command.sourcePath,
-            });
-        }
-        if (!this.state.provider.baseURL || !this.state.provider.apiKey) {
-            const text = createFallbackResponse(trimmed, this.state);
-            this.emitAcodeEvent('assistant_delta', { text });
-            this.emitAcodeEvent('turn_complete', { usage: { inputTokens: trimmed.length, outputTokens: text.length } });
-            return;
-        }
-        this.state.conversation.push({ role: 'user', content: trimmed });
         try {
+            const promptHookResults = await this.hookBus.dispatch("UserPromptSubmit", { prompt: originalPrompt });
+            const promptDeny = findDeniedHookResult(promptHookResults);
+            if (promptDeny) {
+                this.emitAcodeEvent("error", {
+                    message: promptDeny.message || "ACode prompt was denied by hook",
+                });
+                this.emitAcodeEvent("turn_complete", { failed: true });
+                return;
+            }
+            const expandedCommand = this.state.commandRegistry.expand(originalPrompt);
+            const trimmed = expandedCommand?.prompt.trim() || originalPrompt;
+            const commandAllowedTools = expandedCommand?.command.allowedTools;
+            if (expandedCommand) {
+                this.emitAcodeEvent("command_status", {
+                    action: "slash_command",
+                    command: expandedCommand.command.name,
+                    arguments: expandedCommand.argumentsText,
+                    sourcePath: expandedCommand.command.sourcePath,
+                });
+            }
+            if (!this.state.provider.baseURL || !this.state.provider.apiKey) {
+                const text = createFallbackResponse(trimmed, this.state);
+                this.emitAcodeEvent("assistant_delta", { text });
+                this.emitAcodeEvent("turn_complete", {
+                    usage: { inputTokens: trimmed.length, outputTokens: text.length },
+                });
+                return;
+            }
+            const parsedContent = parseAttachmentMessage(trimmed);
+            if (parsedContent.hasImages && !this.state.provider.supportsImageInput) {
+                throw new Error("ACode provider/model is not configured for image input. Enable provider.default.models[model].modalities.input including 'image' or options.supportsImageInput=true.");
+            }
+            const userContent = await materializeImageContent(parsedContent.content);
+            this.state.conversation.push({ role: "user", content: userContent });
             const result = await this.runModelTurn(commandAllowedTools);
-            if (result.text) {
-                this.emitAcodeEvent('assistant_delta', { text: result.text });
+            if (result.text && !this.state.provider.stream) {
+                this.emitAcodeEvent("assistant_delta", { text: result.text });
             }
-            this.emitAcodeEvent('turn_complete', {
-                usage: result.usage ?? { inputTokens: trimmed.length, outputTokens: result.text.length },
+            this.emitAcodeEvent("turn_complete", {
+                usage: result.usage ?? {
+                    inputTokens: trimmed.length,
+                    outputTokens: result.text.length,
+                },
+                ...(result.responseBody ? { responseBody: result.responseBody } : {}),
+                ...(result.finishReason ? { finishReason: result.finishReason } : {}),
             });
         }
         catch (error) {
-            this.emitAcodeEvent('error', {
+            if (this.abortRequested) {
+                this.emitAcodeEvent("turn_complete", { aborted: true });
+                return;
+            }
+            this.emitAcodeEvent("error", {
                 message: error instanceof Error ? error.message : String(error),
             });
-            this.emitAcodeEvent('turn_complete', { failed: true });
+            this.emitAcodeEvent("turn_complete", { failed: true });
+        }
+        finally {
+            this.activeTurn = false;
+            this.abortRequested = false;
         }
     }
-    /** 中止当前轮次；当前骨架无长任务，仅发出完成状态。 */
+    /** 中止当前轮次；由执行轮次统一发出一个终态事件，避免 aborted/failed 双终态。 */
     async abort() {
+        this.abortRequested = this.activeTurn;
         this.abortController?.abort();
         this.abortController = null;
-        if (!this.state.terminated) {
-            this.emitAcodeEvent('turn_complete', { aborted: true });
-        }
     }
     /** 终止 ACode 会话并发出 session_complete。 */
     async stop() {
         if (this.state.terminated) {
             return;
         }
+        this.state.terminated = true;
+        this.abortRequested = this.activeTurn;
+        this.abortController?.abort();
+        this.abortController = null;
+        await runBestEffort("ACode active turn shutdown", this.submitQueue, (message) => {
+            this.emitAcodeEvent("error", { message });
+        });
         await this.disconnectMcpServers();
-        await this.hookBus.dispatch('Stop', { reason: 'session_stop' });
+        await runBestEffort("ACode Stop hooks", this.hookBus.dispatch("Stop", { reason: "session_stop" }), (message) => {
+            this.emitAcodeEvent("error", { message });
+        });
         this.state.terminated = true;
-        this.emitAcodeEvent('session_complete', { exitCode: 0 });
+        if (!this.sessionCompleteEmitted) {
+            this.sessionCompleteEmitted = true;
+            this.emitAcodeEvent("session_complete", { exitCode: 0 });
+        }
     }
     resolveCommandDirs(acodeConfig) {
         const configured = [
@@ -364,23 +857,39 @@ export class ACodeRuntime extends EventEmitter {
             ...(acodeConfig.commandDirs ?? []),
             ...(acodeConfig.commands?.directories ?? []),
         ];
-        return [...new Set(configured.map((directory) => directory.trim()).filter(Boolean))];
+        return [
+            ...new Set(configured.map((directory) => directory.trim()).filter(Boolean)),
+        ];
     }
     async runModelTurn(commandAllowedTools) {
-        let finalText = '';
+        let finalText = "";
         let finalUsage;
+        let finalResponseBody;
+        let finalFinishReason;
         for (let step = 0; step < 5; step += 1) {
             const response = await this.requestChatCompletion(commandAllowedTools);
+            if (this.state.terminated) {
+                throw new Error("ACode runtime was stopped during the active turn");
+            }
             const choice = response.choices?.[0];
+            finalResponseBody = JSON.stringify(response, null, 2);
+            finalFinishReason =
+                typeof choice?.finish_reason === "string"
+                    ? choice.finish_reason
+                    : undefined;
             const message = choice?.message;
-            const content = typeof message?.content === 'string' ? message.content : '';
-            const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+            const content = typeof message?.content === "string" ? message.content : "";
+            const toolCalls = Array.isArray(message?.tool_calls)
+                ? message.tool_calls
+                : [];
             finalUsage = {
                 inputTokens: response.usage?.prompt_tokens ?? response.usage?.input_tokens ?? 0,
-                outputTokens: response.usage?.completion_tokens ?? response.usage?.output_tokens ?? 0,
+                outputTokens: response.usage?.completion_tokens ??
+                    response.usage?.output_tokens ??
+                    0,
             };
             this.state.conversation.push({
-                role: 'assistant',
+                role: "assistant",
                 content: content || null,
                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
             });
@@ -388,57 +897,241 @@ export class ACodeRuntime extends EventEmitter {
                 finalText = content;
             }
             if (toolCalls.length === 0) {
-                return { text: finalText, usage: finalUsage };
+                return {
+                    text: finalText,
+                    usage: finalUsage,
+                    responseBody: finalResponseBody,
+                    finishReason: finalFinishReason,
+                };
             }
             await this.handleToolCalls(toolCalls, commandAllowedTools);
         }
-        return { text: finalText || 'ACode 已达到本轮 MCP 工具调用上限。', usage: finalUsage };
+        return {
+            text: finalText || "ACode 已达到本轮 MCP 工具调用上限。",
+            usage: finalUsage,
+            responseBody: finalResponseBody,
+            finishReason: finalFinishReason,
+        };
     }
     async requestChatCompletion(commandAllowedTools) {
         const provider = this.state.provider;
-        if (!provider.baseURL) {
-            throw new Error('ACode provider baseURL is not configured');
+        const baseURL = provider.baseURL;
+        if (!baseURL) {
+            throw new Error("ACode provider baseURL is not configured");
         }
-        this.abortController = new AbortController();
         const body = {
             model: provider.model,
             messages: this.state.conversation,
-            stream: false,
+            stream: provider.stream,
         };
         const allowedTools = this.state.exposedTools.filter((tool) => isToolAllowed(tool, this.state.permissions, commandAllowedTools));
         if (allowedTools.length > 0) {
             body.tools = toOpenAiTools(allowedTools);
-            body.tool_choice = 'auto';
+            body.tool_choice = "auto";
         }
-        const response = await fetch(normalizeChatCompletionsUrl(provider.baseURL), {
-            method: 'POST',
-            headers: buildRequestHeaders(provider),
-            body: JSON.stringify(body),
-            signal: this.abortController.signal,
+        this.emitAcodeEvent("ai_request", {
+            model: provider.model,
+            endpoint: summarizeProviderUrl(baseURL),
+            stream: provider.stream,
+            messageCount: this.state.conversation.length,
+            toolCount: allowedTools.length,
+            lastUserMessagePreview: summarizeLastUserMessage(this.state.conversation),
+            requestBody: JSON.stringify(body, null, 2),
         });
-        this.abortController = null;
-        if (!response.ok) {
-            throw new Error(`ACode provider request failed: ${response.status} ${await response.text()}`);
+        const maxAttempts = provider.requestRetryCount + 1;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            this.abortController = new AbortController();
+            let timedOut = false;
+            try {
+                return await withTimeout((async () => {
+                    const response = await withTimeout(fetch(normalizeChatCompletionsUrl(baseURL), {
+                        method: "POST",
+                        headers: buildRequestHeaders(provider),
+                        body: JSON.stringify(body),
+                        signal: this.abortController?.signal,
+                    }), provider.requestTimeoutMs, "ACode provider request", () => {
+                        timedOut = true;
+                        this.abortController?.abort();
+                    });
+                    if (!response.ok) {
+                        throw new Error(`ACode provider request failed: ${response.status} ${await response.text()}`);
+                    }
+                    const contentType = response.headers?.get?.("content-type") || "";
+                    if (provider.stream &&
+                        contentType.toLowerCase().includes("text/event-stream")) {
+                        return await this.readChatCompletionStream(response, provider.requestTimeoutMs);
+                    }
+                    const payload = (await withTimeout(response.json(), provider.requestTimeoutMs, "ACode provider response body", () => {
+                        timedOut = true;
+                        this.abortController?.abort();
+                    }));
+                    return isRecord(payload) ? payload : {};
+                })(), 0, "ACode provider request");
+            }
+            catch (error) {
+                let requestError;
+                if (error instanceof Error && error.name === "AbortError") {
+                    requestError = timedOut
+                        ? new Error(`ACode provider request timed out after ${provider.requestTimeoutMs}ms`)
+                        : new Error("ACode provider request aborted");
+                }
+                else {
+                    requestError =
+                        error instanceof Error ? error : new Error(String(error));
+                }
+                const shouldRetry = attempt < maxAttempts &&
+                    !this.abortRequested &&
+                    !this.state.terminated &&
+                    isRetryableProviderRequestError(requestError);
+                if (!shouldRetry) {
+                    throw requestError;
+                }
+                this.emitAcodeEvent("error", {
+                    message: `ACode provider request attempt ${attempt}/${maxAttempts} failed; retrying: ${requestError.message}`,
+                });
+                await delay(DEFAULT_PROVIDER_REQUEST_RETRY_DELAY_MS * attempt);
+            }
+            finally {
+                this.abortController = null;
+            }
         }
-        const payload = await response.json();
-        return isRecord(payload) ? payload : {};
+        throw new Error("ACode provider request failed after all retries");
+    }
+    async readChatCompletionStream(response, idleTimeoutMs) {
+        if (!response.body) {
+            throw new Error("ACode provider stream response has no body");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        const toolCallAccumulators = new Map();
+        let text = "";
+        let buffer = "";
+        const consumeFrame = (frame) => {
+            for (const data of parseSseDataLines(frame)) {
+                if (data === "[DONE]") {
+                    continue;
+                }
+                const payload = JSON.parse(data);
+                if (!isRecord(payload)) {
+                    continue;
+                }
+                const choice = payload.choices?.[0];
+                const delta = choice?.delta;
+                const reasoningText = extractReasoningText(delta);
+                if (reasoningText) {
+                    this.emitAcodeEvent("thinking_delta", { text: reasoningText });
+                }
+                const content = typeof delta?.content === "string" ? delta.content : "";
+                if (content) {
+                    text += content;
+                    this.emitAcodeEvent("assistant_delta", { text: content });
+                }
+                const toolDeltas = Array.isArray(delta?.tool_calls)
+                    ? delta.tool_calls
+                    : [];
+                for (const toolDelta of toolDeltas) {
+                    updateToolCallAccumulator(toolCallAccumulators, toolDelta);
+                }
+            }
+        };
+        while (true) {
+            const { done, value } = await withTimeout(reader.read(), idleTimeoutMs, "ACode provider stream idle", () => this.abortController?.abort());
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const frames = buffer.split(/\r?\n\r?\n/);
+            buffer = frames.pop() ?? "";
+            for (const frame of frames) {
+                consumeFrame(frame);
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.trim()) {
+            consumeFrame(buffer);
+        }
+        return {
+            choices: [
+                {
+                    message: {
+                        content: text || null,
+                        tool_calls: toAccumulatedToolCalls(toolCallAccumulators),
+                    },
+                },
+            ],
+        };
     }
     async handleToolCalls(toolCalls, commandAllowedTools) {
         for (const toolCall of toolCalls) {
             const tool = this.state.exposedTools.find((item) => item.exposedName === toolCall.function.name);
             if (!tool) {
                 this.state.conversation.push({
-                    role: 'tool',
+                    role: "tool",
                     tool_call_id: toolCall.id,
                     content: `ACode MCP tool not found: ${toolCall.function.name}`,
                 });
                 continue;
             }
-            if (tool.kind === 'builtin') {
+            try {
+                if (tool.kind === "builtin") {
+                    const toolArguments = coerceArguments(toolCall.function.arguments);
+                    assertToolPermission(tool, this.state.permissions, commandAllowedTools);
+                    const preResults = await this.hookBus.dispatch("PreToolUse", {
+                        source: "builtin",
+                        toolName: tool.toolName,
+                        exposedName: tool.exposedName,
+                        arguments: toolArguments,
+                    });
+                    const denied = findDeniedHookResult(preResults);
+                    if (denied) {
+                        throw new Error(denied.message ||
+                            `ACode tool denied by hook: ${tool.exposedName}`);
+                    }
+                    this.emitAcodeEvent("mcp_status", {
+                        action: "call_tool",
+                        server: "builtin",
+                        tool: tool.toolName,
+                        exposedName: tool.exposedName,
+                        toolUseId: toolCall.id,
+                        arguments: toolArguments,
+                        argumentsPreview: summarizeToolArguments(toolArguments),
+                    });
+                    const result = await withTimeout(tool.execute(toolArguments), getBuiltInToolTimeoutMs(tool, toolArguments, this.state.provider.mcpToolTimeoutMs), `ACode built-in tool ${tool.toolName}`);
+                    await this.hookBus.dispatch("PostToolUse", {
+                        source: "builtin",
+                        toolName: tool.toolName,
+                        exposedName: tool.exposedName,
+                        result: toToolResultText(result),
+                    });
+                    const resultText = toToolResultText(result);
+                    this.emitAcodeEvent("mcp_status", {
+                        action: "tool_result",
+                        server: "builtin",
+                        tool: tool.toolName,
+                        result: resultText,
+                    });
+                    this.state.conversation.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: resultText,
+                    });
+                    await this.appendSyntheticMultimodalUserMessage(resultText);
+                    continue;
+                }
+                const connection = this.state.mcpConnections.find((item) => item.serverName === tool.serverName);
+                if (!connection) {
+                    this.state.conversation.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: `ACode MCP server not connected: ${tool.serverName}`,
+                    });
+                    continue;
+                }
                 const toolArguments = coerceArguments(toolCall.function.arguments);
                 assertToolPermission(tool, this.state.permissions, commandAllowedTools);
-                const preResults = await this.hookBus.dispatch('PreToolUse', {
-                    source: 'builtin',
+                const preResults = await this.hookBus.dispatch("PreToolUse", {
+                    source: "mcp",
+                    serverName: tool.serverName,
                     toolName: tool.toolName,
                     exposedName: tool.exposedName,
                     arguments: toolArguments,
@@ -447,70 +1140,88 @@ export class ACodeRuntime extends EventEmitter {
                 if (denied) {
                     throw new Error(denied.message || `ACode tool denied by hook: ${tool.exposedName}`);
                 }
-                this.emitAcodeEvent('mcp_status', { action: 'call_tool', server: 'builtin', tool: tool.toolName });
-                const result = await tool.execute(toolArguments);
-                await this.hookBus.dispatch('PostToolUse', {
-                    source: 'builtin',
+                this.emitAcodeEvent("mcp_status", {
+                    action: "call_tool",
+                    server: tool.serverName,
+                    tool: tool.toolName,
+                    exposedName: tool.exposedName,
+                    toolUseId: toolCall.id,
+                    arguments: toolArguments,
+                    argumentsPreview: summarizeToolArguments(toolArguments),
+                });
+                const toolTimeoutMs = isMcpPollingToolName(tool.toolName)
+                    ? this.state.provider.mcpPollingToolTimeoutMs
+                    : this.state.provider.mcpToolTimeoutMs;
+                const result = await withTimeout(connection.client.callTool({
+                    name: tool.toolName,
+                    arguments: toolArguments,
+                }, undefined, { timeout: toolTimeoutMs }), toolTimeoutMs, `ACode MCP tool ${tool.serverName}/${tool.toolName}`);
+                await this.hookBus.dispatch("PostToolUse", {
+                    source: "mcp",
+                    serverName: tool.serverName,
                     toolName: tool.toolName,
                     exposedName: tool.exposedName,
                     result: toToolResultText(result),
                 });
-                this.state.conversation.push({
-                    role: 'tool',
-                    tool_call_id: toolCall.id,
-                    content: toToolResultText(result),
+                const resultText = toToolResultText(result);
+                this.emitAcodeEvent("mcp_status", {
+                    action: "tool_result",
+                    server: tool.serverName,
+                    tool: tool.toolName,
+                    result: resultText,
                 });
-                continue;
-            }
-            const connection = this.state.mcpConnections.find((item) => item.serverName === tool.serverName);
-            if (!connection) {
                 this.state.conversation.push({
-                    role: 'tool',
+                    role: "tool",
                     tool_call_id: toolCall.id,
-                    content: `ACode MCP server not connected: ${tool.serverName}`,
+                    content: resultText,
                 });
-                continue;
+                await this.appendSyntheticMultimodalUserMessage(resultText);
             }
-            const toolArguments = coerceArguments(toolCall.function.arguments);
-            assertToolPermission(tool, this.state.permissions, commandAllowedTools);
-            const preResults = await this.hookBus.dispatch('PreToolUse', {
-                source: 'mcp',
-                serverName: tool.serverName,
-                toolName: tool.toolName,
-                exposedName: tool.exposedName,
-                arguments: toolArguments,
-            });
-            const denied = findDeniedHookResult(preResults);
-            if (denied) {
-                throw new Error(denied.message || `ACode tool denied by hook: ${tool.exposedName}`);
+            catch (error) {
+                this.appendToolFailureResult(toolCall, tool, error);
             }
-            this.emitAcodeEvent('mcp_status', { action: 'call_tool', server: tool.serverName, tool: tool.toolName });
-            const result = await connection.client.callTool({
-                name: tool.toolName,
-                arguments: toolArguments,
-            });
-            await this.hookBus.dispatch('PostToolUse', {
-                source: 'mcp',
-                serverName: tool.serverName,
-                toolName: tool.toolName,
-                exposedName: tool.exposedName,
-                result: toToolResultText(result),
-            });
-            this.state.conversation.push({
-                role: 'tool',
-                tool_call_id: toolCall.id,
-                content: toToolResultText(result),
+        }
+    }
+    async appendSyntheticMultimodalUserMessage(toolResultText) {
+        const parsedContent = parseAttachmentMessage(toolResultText);
+        if (!parsedContent.hasImages) {
+            return;
+        }
+        if (!this.state.provider.supportsImageInput) {
+            this.emitAcodeEvent("error", {
+                message: "ACode skipped image content from tool result because the provider/model is not configured for image input.",
             });
+            return;
         }
+        const content = await materializeImageContent(parsedContent.content);
+        this.state.conversation.push({ role: "user", content });
+    }
+    appendToolFailureResult(toolCall, tool, error) {
+        const resultText = toToolErrorResultText(tool, error);
+        this.emitAcodeEvent("error", {
+            message: `ACode tool failed: ${tool.exposedName}: ${getErrorMessage(error)}`,
+        });
+        this.emitAcodeEvent("mcp_status", {
+            action: "tool_result",
+            server: tool.kind === "mcp" ? tool.serverName : "builtin",
+            tool: tool.toolName,
+            result: resultText,
+            failed: true,
+        });
+        this.state.conversation.push({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: resultText,
+        });
     }
-    async connectMcpServers(servers) {
+    async connectMcpServers(servers, timeoutMs) {
         const connections = [];
         for (const [serverName, serverSpec] of Object.entries(servers)) {
             try {
-                const client = new Client({ name: 'acode', version: '0.1.0' });
+                const client = new Client({ name: "acode", version: "0.1.0" });
                 const transport = this.createMcpTransport(serverSpec);
-                await client.connect(transport);
-                const { tools } = await client.listTools();
+                await withTimeout(client.connect(transport), timeoutMs, `ACode MCP server ${serverName} connect`);
+                const { tools } = await withTimeout(client.listTools(), timeoutMs, `ACode MCP server ${serverName} listTools`);
                 connections.push({
                     serverName,
                     client,
@@ -518,15 +1229,17 @@ export class ACodeRuntime extends EventEmitter {
                     tools: tools.map((tool) => ({
                         serverName,
                         toolName: tool.name,
-                        kind: 'mcp',
+                        kind: "mcp",
                         exposedName: normalizeToolName(serverName, tool.name),
                         description: tool.description,
-                        inputSchema: isJsonObject(tool.inputSchema) ? tool.inputSchema : { type: 'object', properties: {} },
+                        inputSchema: isJsonObject(tool.inputSchema)
+                            ? tool.inputSchema
+                            : { type: "object", properties: {} },
                     })),
                 });
             }
             catch (error) {
-                this.emitAcodeEvent('error', {
+                this.emitAcodeEvent("error", {
                     message: `ACode MCP server failed to connect: ${serverName}: ${error instanceof Error ? error.message : String(error)}`,
                 });
             }
@@ -534,38 +1247,37 @@ export class ACodeRuntime extends EventEmitter {
         return connections;
     }
     createMcpTransport(serverSpec) {
-        if (serverSpec.type === 'stdio' || serverSpec.command) {
+        if (serverSpec.type === "stdio" || serverSpec.command) {
             if (!serverSpec.command) {
-                throw new Error('stdio MCP server requires command');
+                throw new Error("stdio MCP server requires command");
             }
             return new StdioClientTransport({
                 command: serverSpec.command,
                 args: serverSpec.args,
                 cwd: serverSpec.cwd || this.config.workingDirectory,
                 env: { ...(this.config.env ?? {}), ...(serverSpec.env ?? {}) },
-                stderr: 'pipe',
+                stderr: "pipe",
             });
         }
         if (!serverSpec.url) {
-            throw new Error('remote MCP server requires url');
+            throw new Error("remote MCP server requires url");
         }
-        const requestInit = serverSpec.headers ? { headers: serverSpec.headers } : undefined;
-        if (serverSpec.type === 'sse') {
+        const requestInit = serverSpec.headers
+            ? { headers: serverSpec.headers }
+            : undefined;
+        if (serverSpec.type === "sse") {
             return new SSEClientTransport(new URL(serverSpec.url), { requestInit });
         }
-        return new StreamableHTTPClientTransport(new URL(serverSpec.url), { requestInit });
+        return new StreamableHTTPClientTransport(new URL(serverSpec.url), {
+            requestInit,
+        });
     }
     async disconnectMcpServers() {
         const connections = this.state.mcpConnections;
         this.state.mcpConnections = [];
         this.state.exposedTools = [];
-        await Promise.all(connections.map(async (connection) => {
-            try {
-                await connection.transport.close();
-            }
-            catch {
-                // Best-effort shutdown; stale MCP transports must not block runtime termination.
-            }
-        }));
+        await Promise.all(connections.map((connection) => runBestEffort(`ACode MCP server ${connection.serverName} close`, connection.transport.close(), (message) => {
+            this.emitAcodeEvent("error", { message });
+        }, this.state.provider.mcpToolTimeoutMs)));
     }
 }