@ai-zen/agents-sdk 1.0.0-alpha.22 → 1.0.0-alpha.23

package/dist/scope/plugins/builtin/RenameTool.js

@@ -3,17 +3,17 @@ import { SdkCallbackTool } from "./SdkCallbackTool.js";
 export class RenameTool extends SdkCallbackTool {
     function = {
         name: "rename",
-        description: "重命名或移动文件/目录（相当于 mv 命令）",
+        description: "Rename or move a file/directory (equivalent to the mv command)",
         parameters: {
             type: "object",
             properties: {
                 oldPath: {
                     type: "string",
-                    description: "原路径",
+                    description: "Original path",
                 },
                 newPath: {
                     type: "string",
-                    description: "新路径",
+                    description: "New path",
                 },
             },
             required: ["oldPath", "newPath"],

package/dist/scope/plugins/builtin/RmTool.js

@@ -3,17 +3,17 @@ import { SdkCallbackTool } from "./SdkCallbackTool.js";
 export class RmTool extends SdkCallbackTool {
     function = {
         name: "rm",
-        description: "删除文件或目录",
+        description: "Delete a file or directory",
         parameters: {
             type: "object",
             properties: {
                 path: {
                     type: "string",
-                    description: "文件或目录路径",
+                    description: "File or directory path",
                 },
                 recursive: {
                     type: "boolean",
-                    description: "是否递归删除子目录",
+                    description: "Whether to delete subdirectories recursively",
                 },
             },
             required: ["path"],

package/dist/scope/plugins/builtin/SleepTool.js

@@ -2,13 +2,13 @@ import { SdkCallbackTool } from "./SdkCallbackTool.js";
 export class SleepTool extends SdkCallbackTool {
     function = {
         name: "sleep",
-        description: "等待指定的时间（毫秒）。用于需要延迟执行的场景，例如等待其他操作完成、操作间隔控制等。注意：过长的等待时间会影响响应速度，建议不超过 30000 毫秒（30 秒）。",
+        description: "Wait for the specified time in milliseconds. Use it when a delay is needed, for example to wait for another operation to finish or to space out actions. Note: long waits slow down responses; keep it at or below 30000 milliseconds (30 seconds).",
         parameters: {
             type: "object",
             properties: {
                 ms: {
                     type: "number",
-                    description: "等待的毫秒数（1 秒 = 1000 毫秒）。建议不超过 30000（30 秒）。",
+                    description: "Milliseconds to wait (1 second = 1000 milliseconds). Values above 30000 (30 seconds) are not recommended.",
                 },
             },
             required: ["ms"],
@@ -23,14 +23,14 @@ export class SleepTool extends SdkCallbackTool {
         if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) {
             return JSON.stringify({
                 success: false,
-                error: "ms 必须是正整数",
+                error: "ms must be a positive integer",
             });
         }
         if (ms > 300_000) {
             // 超过 5 分钟给出警告
             return JSON.stringify({
                 success: false,
-                error: `等待时间 ${ms}ms 过长，建议不超过 300000ms（5 分钟）。如需长时间等待请分段执行。`,
+                error: `Wait time ${ms}ms is too long, keep it at or below 300000ms (5 minutes). For longer waits, split them into shorter steps`,
             });
         }
         // 若 signal 已处于 aborted，直接返回中断结果，避免不必要的等待
@@ -53,14 +53,14 @@ export class SleepTool extends SdkCallbackTool {
             return JSON.stringify({
                 success: false,
                 aborted: true,
-                error: "等待被中断（aborted）",
+                error: "Wait aborted",
             });
         }
         return JSON.stringify({
             success: true,
             waitedMs: ms,
             waitedSeconds: (ms / 1000).toFixed(1),
-            message: `已等待 ${ms}ms（${(ms / 1000).toFixed(1)} 秒）`,
+            message: `Waited ${ms}ms (${(ms / 1000).toFixed(1)} seconds)`,
         });
     }
 }

package/dist/scope/plugins/builtin/SpawnTool.js

@@ -3,21 +3,21 @@ import { SdkCallbackTool } from "./SdkCallbackTool.js";
 export class SpawnTool extends SdkCallbackTool {
     function = {
         name: "spawn",
-        description: "异步执行命令，启动程序后立即返回，不等待执行结果。适用于启动长期运行的进程（如服务器、监听程序、GUI应用等）或不需要等待结果的命令。注意：该工具本身不捕获命令的输出；若需获取/留存输出，可在命令中使用 shell 重定向写入文件（如 `> /path/file`，支持 `>>` 追加、`|` 管道）。命令经 shell 解析执行。",
+        description: "Spawn a command asynchronously and return immediately without waiting for the result. Use it for long-running processes (servers, watchers, GUI apps, etc.) or commands whose result you do not need to wait for. Note: this tool does not capture the command's output itself; to retain or inspect output, use shell redirection to a file inside the command (e.g. `> /path/file`; `>>` append and `|` pipes are supported). The command is parsed and executed by the shell.",
         parameters: {
             type: "object",
             properties: {
                 command: {
                     type: "string",
-                    description: "要执行的命令（含参数）",
+                    description: "Command to execute (including arguments)",
                 },
                 cwd: {
                     type: "string",
-                    description: "工作目录（可选，默认当前工作目录）",
+                    description: "Working directory (optional, defaults to the current working directory)",
                 },
                 detached: {
                     type: "boolean",
-                    description: "是否完全脱离当前进程组（可选，默认 false）。设为 true 时，即使当前 Agent 进程退出，启动的程序仍会继续运行。适用于需要独立运行的守护进程或 GUI 程序。",
+                    description: "Whether to fully detach from the current process group (optional, defaults to false). When true, the spawned program keeps running even after the current Agent process exits. Use it for daemons or GUI programs that must run independently.",
                 },
             },
             required: ["command"],
@@ -48,7 +48,7 @@ export class SpawnTool extends SdkCallbackTool {
                 resolve(JSON.stringify({
                     success: false,
                     pid: null,
-                    message: `启动失败: ${err.message}`,
+                    message: `Failed to start: ${err.message}`,
                 }));
             });
             child.on("spawn", () => {
@@ -58,7 +58,7 @@ export class SpawnTool extends SdkCallbackTool {
                 resolve(JSON.stringify({
                     success: true,
                     pid: child.pid ?? null,
-                    message: `进程已启动 (PID: ${child.pid ?? "unknown"})`,
+                    message: `Process started (PID: ${child.pid ?? "unknown"})`,
                 }));
             });
             child.on("exit", (code) => {
@@ -70,8 +70,8 @@ export class SpawnTool extends SdkCallbackTool {
                     pid: child.pid ?? null,
                     exitCode: code,
                     message: code === null
-                        ? `进程已退出 (PID: ${child.pid ?? "unknown"})`
-                        : `进程已退出 (PID: ${child.pid ?? "unknown"}, 退出码: ${code})`,
+                        ? `Process exited (PID: ${child.pid ?? "unknown"})`
+                        : `Process exited (PID: ${child.pid ?? "unknown"}, exit code: ${code})`,
                 }));
             });
             const timeout = setTimeout(() => {
@@ -81,7 +81,7 @@ export class SpawnTool extends SdkCallbackTool {
                 resolve(JSON.stringify({
                     success: true,
                     pid: child.pid ?? null,
-                    message: `进程已启动 (PID: ${child.pid ?? "unknown"})`,
+                    message: `Process started (PID: ${child.pid ?? "unknown"})`,
                 }));
             }, 500);
             const cleanup = () => {

package/dist/scope/plugins/builtin/ViewImageTool.js

@@ -35,13 +35,13 @@ export class ViewImageTool extends SdkCallbackTool {
     }
     function = {
         name: "view_image",
-        description: "查看一张图片并分析其内容。传入本地图片路径或 http(s) 图片 URL。本地图片优先上传（端点支持 Files API 时）否则以 base64 内联引用，网络图片直接引用。不支持本地 URL（如 file:// 协议、指向本机 localhost/127.0.0.1 的 http(s) 地址），本地图片请使用文件路径。适合识别图片文字、描述图片内容、分析图表等。",
+        description: "View an image and analyze its content. Pass a local image path or an http(s) image URL. Local images are uploaded when the endpoint supports the Files API and are otherwise referenced as inline base64; remote images are referenced directly. Local URLs are not supported (such as the file:// protocol, or http(s) addresses pointing to localhost/127.0.0.1 on this machine); use a file path for local images. Suitable for reading text in images, describing image content and analyzing charts.",
         parameters: {
             type: "object",
             properties: {
                 path_or_url: {
                     type: "string",
-                    description: "本地图片路径（相对/绝对）或 http(s) 图片 URL。支持的格式：JPEG、PNG、GIF、WebP。不支持本地 URL（如 file:// 协议、指向本机 localhost/127.0.0.1 的 http(s) 地址），本地图片请使用文件路径。",
+                    description: "Local image path (relative or absolute) or an http(s) image URL. Supported formats: JPEG, PNG, GIF, WebP. Local URLs are not supported (such as the file:// protocol, or http(s) addresses pointing to localhost/127.0.0.1 on this machine); use a file path for local images.",
                 },
             },
             required: ["path_or_url"],
@@ -55,12 +55,12 @@ export class ViewImageTool extends SdkCallbackTool {
         const signal = ctx?.signal;
         const target = input?.path_or_url;
         if (!target || !target.trim()) {
-            return "view_image 需要提供 path_or_url 参数（本地图片路径或 http(s) URL）。";
+            return "view_image requires the path_or_url parameter (a local image path or an http(s) URL)";
         }
         const value = target.trim();
         // 拒绝服务商无法访问的"本地 URL"：file:// 等本地协议，或指向本机回环地址的 http(s) 地址
         if (isLocalUrl(value)) {
-            return "不支持本地 URL（API 服务商无法下载访问）。本地图片请使用文件路径，而不是本地链接。";
+            return "Local URLs are not supported (the API provider cannot download them). Use a file path for local images, not a local link";
         }
         // 按当前模型定位端点：决定走 Files API 上传还是 base64 内联
         const { model, endpoint } = resolveModelAndEndpoint(this.env.config, ctx?.agent?.model);
@@ -74,11 +74,11 @@ export class ViewImageTool extends SdkCallbackTool {
                     await fs.stat(abs);
                 }
                 catch {
-                    return `本地图片不存在: ${abs}`;
+                    return `Local image not found: ${abs}`;
                 }
                 const mime = mimeOf(abs);
                 if (!mime || !mime.startsWith("image/")) {
-                    return `不支持的图片格式 "${path.extname(abs) || "(无扩展名)"}"。支持的格式：JPEG、PNG、GIF、WebP。`;
+                    return `Unsupported image format "${path.extname(abs) || "(no extension)"}". Supported formats: JPEG, PNG, GIF, WebP`;
                 }
             }
             const result = await fileToContentSection({
@@ -87,21 +87,21 @@ export class ViewImageTool extends SdkCallbackTool {
                 model,
                 signal,
             });
-            const label = isUrl ? `已获取网络图片：${value}` : `已获取本地图片（${path.basename(value)}）`;
+            const label = isUrl ? `Fetched remote image: ${value}` : `Fetched local image (${path.basename(value)})`;
             const how = result.transport === "files-api"
-                ? `，已上传至 Files API（file_id: ${result.section.file_id ?? "?"}）`
+                ? `, uploaded to the Files API (file_id: ${result.section.file_id ?? "?"})`
                 : result.transport === "inline"
-                    ? `，已按 base64 内联（${(result.bytes / 1024).toFixed(0)} KB）`
+                    ? `, inlined as base64 (${(result.bytes / 1024).toFixed(0)} KB)`
                     : "";
-            const extra = result.warning ? `（降级说明：${result.warning}）` : "";
+            const extra = result.warning ? ` (fallback: ${result.warning})` : "";
             return [{ type: "text", text: `${label}${how}${extra}` }, result.section];
         }
         catch (error) {
             // 中断（abort）时返回明确的中断结果
             if (signal?.aborted) {
-                return "图片查看被中断（aborted）";
+                return "Image view aborted";
             }
-            return `查看图片失败: ${error instanceof Error ? error.message : String(error)}`;
+            return `Failed to view image: ${error instanceof Error ? error.message : String(error)}`;
         }
     }
 }

package/dist/scope/plugins/builtin/WriteTool.js

@@ -4,17 +4,17 @@ import { SdkCallbackTool } from "./SdkCallbackTool.js";
 export class WriteTool extends SdkCallbackTool {
     function = {
         name: "write",
-        description: "写入文件",
+        description: "Write a file",
         parameters: {
             type: "object",
             properties: {
                 path: {
                     type: "string",
-                    description: "文件路径",
+                    description: "File path",
                 },
                 content: {
                     type: "string",
-                    description: "文件内容",
+                    description: "File content",
                 },
             },
             required: ["path", "content"],

package/dist/scope/plugins/mcp/McpConnectionManager.js

@@ -141,7 +141,7 @@ export class McpConnectionManager {
                 }));
             }
             catch (err) {
-                getLogger().error(`[McpConnectionManager] 获取 "${name}" 工具列表失败: ${err?.message ?? err}`);
+                getLogger().error(`[McpConnectionManager] Failed to list tools for "${name}": ${err?.message ?? err}`);
             }
         }
         if (serverCaps?.resources) {
@@ -155,7 +155,7 @@ export class McpConnectionManager {
                 }));
             }
             catch (err) {
-                getLogger().error(`[McpConnectionManager] 获取 "${name}" 资源列表失败: ${err?.message ?? err}`);
+                getLogger().error(`[McpConnectionManager] Failed to list resources for "${name}": ${err?.message ?? err}`);
             }
         }
         if (serverCaps?.prompts) {
@@ -167,7 +167,7 @@ export class McpConnectionManager {
                 }));
             }
             catch (err) {
-                getLogger().error(`[McpConnectionManager] 获取 "${name}" 提示列表失败: ${err?.message ?? err}`);
+                getLogger().error(`[McpConnectionManager] Failed to list prompts for "${name}": ${err?.message ?? err}`);
             }
         }
         const entry = this.servers.get(name) ?? { state: "connecting" };
@@ -190,7 +190,7 @@ export class McpConnectionManager {
         }
         if (config.transport === "stdio") {
             if (!config.command) {
-                throw new Error(`MCP stdio server 缺少 command`);
+                throw new Error(`MCP stdio server is missing command`);
             }
             return new StdioClientTransport({
                 command: config.command,
@@ -201,7 +201,7 @@ export class McpConnectionManager {
         // http 使用 Streamable HTTP 传输（POST + 可选 SSE 流）
         if (config.transport === "http") {
             if (!config.url) {
-                throw new Error(`MCP http server 缺少 url`);
+                throw new Error(`MCP http server is missing url`);
             }
             return new StreamableHTTPClientTransport(new URL(config.url), {
                 requestInit: config.headers ? { headers: config.headers } : undefined,
@@ -210,13 +210,13 @@ export class McpConnectionManager {
         // sse 使用旧版 HTTP+SSE 传输（GET 建立 SSE 流，POST 发送消息）
         if (config.transport === "sse") {
             if (!config.url) {
-                throw new Error(`MCP sse server 缺少 url`);
+                throw new Error(`MCP sse server is missing url`);
             }
             return new SSEClientTransport(new URL(config.url), {
                 requestInit: config.headers ? { headers: config.headers } : undefined,
             });
         }
-        throw new Error(`不支持的 MCP transport 类型: ${config.transport}`);
+        throw new Error(`Unsupported MCP transport type: ${config.transport}`);
     }
     // ---- 断开 ----
     async disconnect(name) {

package/dist/scope/plugins/mcp/discover.js

@@ -82,7 +82,7 @@ export async function discoverMcpServers(paths) {
             }
         }
         catch (err) {
-            getLogger().warn(`[sdk] 解析 MCP 配置失败: ${path} — ${err?.message ?? err}`);
+            getLogger().warn(`[sdk] Failed to parse MCP config: ${path} — ${err?.message ?? err}`);
         }
     }
     return items;

package/dist/scope/plugins/mcp/mcpTools.js

@@ -3,7 +3,7 @@ import { fileToContentSection, resolveModelAndEndpoint } from "../../../shared/c
 import { createDisclosureParam } from "../../disclosure.js";
 import { DEFAULT_MAX_TOOL_OUTPUT, guardOutput, headTailPreview } from "../builtin/outputGuard.js";
 import { getLogger } from "../../../shared/logger.js";
-const EMPTY_HINT = "（当前没有可用的 MCP 服务器，请联系用户添加）";
+const EMPTY_HINT = "(No MCP servers available, ask the user to add one)";
 /**
  * 创建 load_mcp 工具。
  * server 枚举由 filteredMcps （完整 McpServerConfig[]）自动推导，
@@ -16,16 +16,16 @@ export function createLoadMcpTool(mcpManager, filteredMcps) {
         configMap.set(s.id, s);
     }
     const ids = filteredMcps.map((s) => s.id);
-    const param = createDisclosureParam(ids, "选择一个 MCP 服务器", EMPTY_HINT);
+    const param = createDisclosureParam(ids, "MCP server name", EMPTY_HINT);
     // 拼接各 MCP 服务器的描述供 LLM 参考（对齐 load_skill 的处理方式）
     const mcpDescriptions = filteredMcps
-        .map((s) => `  - ${s.id}: ${s.description || "无描述"}`)
+        .map((s) => `  - ${s.id}: ${s.description || "No description"}`)
         .join("\n");
-    const serverIdDescription = `${param.description}\n\n各 MCP 服务器说明：\n${mcpDescriptions || "  无可用 MCP 服务器"}`;
+    const serverIdDescription = `${param.description}\n\nAvailable MCP servers:\n${mcpDescriptions || "  No MCP servers available"}`;
     return new CallbackTool({
         function: {
             name: "load_mcp",
-            description: "连接到指定 MCP 服务器，获取其可用工具和资源列表。可用 include_manifest=false 仅建立连接、不返回清单（适用于上文中已有该清单的场景）。",
+            description: "Connect to the specified MCP server and get the list of tools and resources it exposes. Pass include_manifest=false to only establish the connection without returning the manifest (useful when the manifest is already in context).",
             parameters: {
                 type: "object",
                 properties: {
@@ -36,7 +36,7 @@ export function createLoadMcpTool(mcpManager, filteredMcps) {
                     },
                     include_manifest: {
                         type: "boolean",
-                        description: "是否返回该服务器的完整能力清单（工具与资源）。可选，默认 true。若你的上文中已存在该清单（例如本会话早前加载过，而进程重启后连接已失效），可设为 false 仅建立连接、只返回摘要，以节省上下文 token",
+                        description: "Whether to return the server's full capability manifest (tools and resources). Optional, defaults to true. If the manifest is already in your context (for example it was loaded earlier in this session but the connection was dropped after a process restart), set it to false to only establish the connection and return a summary, saving context tokens",
                         default: true,
                     },
                 },
@@ -48,7 +48,7 @@ export function createLoadMcpTool(mcpManager, filteredMcps) {
             const serverName = input.server;
             const config = configMap.get(serverName);
             if (!config) {
-                return `❌ MCP 服务器 "${serverName}" 不存在`;
+                return `❌ MCP server "${serverName}" is not configured`;
             }
             // 披露开关：默认返回完整清单；显式传 false 时仅建立连接、只返回摘要
             const includeManifest = input.include_manifest !== false;
@@ -64,12 +64,12 @@ export function createLoadMcpTool(mcpManager, filteredMcps) {
                     manifest = await mcpManager.connect(serverName, config);
                 }
                 catch (error) {
-                    return `无法连接到 "${serverName}": ${error?.message ?? error}`;
+                    return `Failed to connect to "${serverName}": ${error?.message ?? error}`;
                 }
             }
             // 静默模式：只回吐摘要（清单仍留在管理器内，供 call_mcp_tool 使用）
             if (!includeManifest) {
-                getLogger().info(`[load_mcp] ${serverName}: 已连接（未披露清单：工具 ${manifest.tools.length} 个，资源 ${manifest.resources.length} 个）`);
+                getLogger().info(`[load_mcp] ${serverName}: connected (manifest not disclosed: ${manifest.tools.length} tools, ${manifest.resources.length} resources)`);
                 return JSON.stringify({
                     server: serverName,
                     connected: true,
@@ -117,7 +117,7 @@ async function mediaSection(data, mime, media) {
     catch (error) {
         return {
             type: "text",
-            text: `[媒体] 无法转换（${mime}）：${error?.message ?? error}`,
+            text: `[media] Failed to convert (${mime}): ${error?.message ?? error}`,
         };
     }
 }
@@ -161,11 +161,11 @@ async function toMessageSection(block, media) {
                 const mime = r.mimeType ?? "application/octet-stream";
                 return await mediaSection(r.blob, mime, media);
             }
-            return { type: "text", text: `[资源] ${r.uri ?? "(未知 URI)"}` };
+            return { type: "text", text: `[resource] ${r.uri ?? "(unknown URI)"}` };
         }
         case "resource_link": {
             const parts = [block.name, block.uri, block.mimeType].filter(Boolean);
-            return { type: "text", text: `[资源链接] ${parts.join(" · ")}` };
+            return { type: "text", text: `[resource_link] ${parts.join(" · ")}` };
         }
         case "text":
             return { type: "text", text: block.text ?? "" };
@@ -200,8 +200,8 @@ async function protectCallOutput(output, env) {
             return JSON.stringify({
                 outputTooLarge: true,
                 isError: isError || undefined,
-                warning: `文本输出过大：共 ${chars} 字符，超过上限 ${limit} 字符。` +
-                    `完整文本已落盘（result.txt），可用 read 分批读取。`,
+                warning: `Text output too large: ${chars} characters, exceeding the limit of ${limit} characters. ` +
+                    `The full text has been written to disk (result.txt); use read to page through it.`,
                 files: ctx.files,
                 chars,
                 ...preview,
@@ -228,9 +228,9 @@ async function protectCallOutput(output, env) {
     // 未超限：无媒体 → 纯字符串；有媒体 → 原序块数组
     const hasMedia = sections.some((s) => s.type !== "text");
     if (!hasMedia)
-        return isError ? `❌ 工具执行出错:\n${fullText}` : fullText;
+        return isError ? `❌ Tool execution failed:\n${fullText}` : fullText;
     return isError
-        ? [{ type: "text", text: "❌ 工具执行出错:" }, ...sections]
+        ? [{ type: "text", text: "❌ Tool execution failed:" }, ...sections]
         : sections;
 }
 /**
@@ -247,13 +247,13 @@ export function createCallMcpTool(mcpManager, env) {
     return new CallbackTool({
         function: {
             name: "call_mcp_tool",
-            description: "调用已连接 MCP 服务器上的指定工具。需先通过 load_mcp 连接服务器。文本输出过大时会落盘并只返回头尾预览；图片、音频等媒体会保留：端点支持 Files API 时上传后以 file_id 引用，否则 base64 内联。",
+            description: "Call a tool exposed by a connected MCP server. Connect the server with load_mcp first. Large text output is written to disk and only a head/tail preview is returned; images, audio and other media are preserved: uploaded and referenced by file_id when the endpoint supports the Files API, otherwise inlined as base64.",
             parameters: {
                 type: "object",
                 properties: {
-                    server: { type: "string", description: "MCP 服务器名称" },
-                    tool: { type: "string", description: "工具名称" },
-                    arguments: { type: "object", description: "工具参数" },
+                    server: { type: "string", description: "MCP server name" },
+                    tool: { type: "string", description: "Tool name" },
+                    arguments: { type: "object", description: "Tool arguments" },
                 },
                 required: ["server", "tool", "arguments"],
                 additionalProperties: false,
@@ -263,11 +263,11 @@ export function createCallMcpTool(mcpManager, env) {
             const serverName = input.server;
             const state = mcpManager.getState(serverName);
             if (state !== "connected") {
-                return `请先使用 load_mcp 连接 "${serverName}"`;
+                return `Call load_mcp to connect "${serverName}" first`;
             }
             const client = mcpManager.getClient(serverName);
             if (!client) {
-                return `MCP 服务器 "${serverName}" 的客户端不可用`;
+                return `MCP server "${serverName}" client is not available`;
             }
             try {
                 mcpManager.touch(serverName);
@@ -294,7 +294,7 @@ export function createCallMcpTool(mcpManager, env) {
                 return await protectCallOutput({ sections, fullText, chars, isError }, env);
             }
             catch (error) {
-                return `❌ 调用 "${input.tool}" 失败: ${error?.message ?? error}`;
+                return `❌ Failed to call "${input.tool}": ${error?.message ?? error}`;
             }
         },
     });
@@ -306,12 +306,12 @@ export function createReadMcpResourceTool(mcpManager, env) {
     return new CallbackTool({
         function: {
             name: "read_mcp_resource",
-            description: "读取已连接 MCP 服务器上的指定资源（文档、数据、图片等）。文本原样返回；图片等媒体按端点能力上传（file_id）或 base64 内联，不会被丢弃。",
+            description: "Read a resource (document, data, image, etc.) from a connected MCP server. Text is returned as-is; images and other media are uploaded (file_id) or inlined as base64 depending on endpoint capabilities, and are never dropped.",
             parameters: {
                 type: "object",
                 properties: {
-                    server: { type: "string", description: "MCP 服务器名称" },
-                    uri: { type: "string", description: "资源 URI" },
+                    server: { type: "string", description: "MCP server name" },
+                    uri: { type: "string", description: "Resource URI" },
                 },
                 required: ["server", "uri"],
                 additionalProperties: false,
@@ -321,11 +321,11 @@ export function createReadMcpResourceTool(mcpManager, env) {
             const serverName = input.server;
             const state = mcpManager.getState(serverName);
             if (state !== "connected") {
-                return `请先使用 load_mcp 连接 "${serverName}"`;
+                return `Call load_mcp to connect "${serverName}" first`;
             }
             const client = mcpManager.getClient(serverName);
             if (!client) {
-                return `MCP 服务器 "${serverName}" 的客户端不可用`;
+                return `MCP server "${serverName}" client is not available`;
             }
             try {
                 mcpManager.touch(serverName);
@@ -349,7 +349,7 @@ export function createReadMcpResourceTool(mcpManager, env) {
                 return await protectCallOutput({ sections, fullText, chars, isError: false }, env);
             }
             catch (error) {
-                return `❌ 读取资源 "${input.uri}" 失败: ${error?.message ?? error}`;
+                return `❌ Failed to read resource "${input.uri}": ${error?.message ?? error}`;
             }
         },
     });

package/dist/scope/plugins/skills/discover.js

@@ -165,27 +165,27 @@ const VALID_NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 export function validateSkill(skillId, fm) {
     const errors = [];
     if (!fm.name || fm.name.length === 0) {
-        errors.push({ skillId, field: "name", message: "必须存在且非空" });
+        errors.push({ skillId, field: "name", message: "Must be present and non-empty" });
     }
     else {
         if (fm.name.length > 64) {
-            errors.push({ skillId, field: "name", message: `超过 64 字符（当前 ${fm.name.length}）` });
+            errors.push({ skillId, field: "name", message: `Exceeds 64 characters (currently ${fm.name.length})` });
         }
         if (!VALID_NAME_RE.test(fm.name)) {
-            errors.push({ skillId, field: "name", message: `"${fm.name}" 不符合规范：仅允许小写字母、数字、连字符，且不能首尾或连续连字符` });
+            errors.push({ skillId, field: "name", message: `"${fm.name}" is not valid: only lowercase letters, digits and hyphens are allowed, and it must not start, end or contain consecutive hyphens` });
         }
         if (fm.name !== skillId) {
-            errors.push({ skillId, field: "name", message: `"${fm.name}" 与目录名 "${skillId}" 不一致` });
+            errors.push({ skillId, field: "name", message: `"${fm.name}" does not match the directory name "${skillId}"` });
         }
     }
     if (!fm.description || fm.description.length === 0) {
-        errors.push({ skillId, field: "description", message: "必须存在且非空" });
+        errors.push({ skillId, field: "description", message: "Must be present and non-empty" });
     }
     else if (fm.description.length > 1024) {
-        errors.push({ skillId, field: "description", message: `超过 1024 字符（当前 ${fm.description.length}）` });
+        errors.push({ skillId, field: "description", message: `Exceeds 1024 characters (currently ${fm.description.length})` });
     }
     if (fm.compatibility && fm.compatibility.length > 500) {
-        errors.push({ skillId, field: "compatibility", message: `超过 500 字符（当前 ${fm.compatibility.length}）` });
+        errors.push({ skillId, field: "compatibility", message: `Exceeds 500 characters (currently ${fm.compatibility.length})` });
     }
     return errors;
 }