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

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;
 }

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

@@ -2,23 +2,23 @@ import { CallbackTool, Agent, AgentToolLazy, Message } from "@ai-zen/agents-core
 import { createDisclosureParam } from "../../disclosure.js";
 import { readSkill } from "./discover.js";
 import { promises as fs } from "node:fs";
-const EMPTY_HINT = "（当前没有可用的 Skill，请联系用户添加）";
+const EMPTY_HINT = "(No Skills are currently available, please ask the user to add one)";
 /**
  * 创建 load_skill 工具。
  * 枚举所有允许的 skill（不限是否支持子 Agent），由 filteredSkills 提供完整信息。
  */
 export function createLoadSkillTool(skillDirs, filteredSkills) {
     const ids = filteredSkills.map((s) => s.id);
-    const param = createDisclosureParam(ids, "选择一个 Skill", EMPTY_HINT);
+    const param = createDisclosureParam(ids, "Select a Skill", EMPTY_HINT);
     // 拼接各 skill 的描述供 LLM 参考
     const skillDescriptions = filteredSkills
-        .map((s) => `  - ${s.id}: ${s.description || "无描述"}`)
+        .map((s) => `  - ${s.id}: ${s.description || "No description"}`)
         .join("\n");
-    const skillIdDescription = `${param.description}\n\n各 Skill 说明：\n${skillDescriptions || "  无可用 Skill"}`;
+    const skillIdDescription = `${param.description}\n\nSkill descriptions:\n${skillDescriptions || "  No Skills available"}`;
     return new CallbackTool({
         function: {
             name: "load_skill",
-            description: "加载指定 Skill 的完整指导文档。Skill 是预制的专业指导，加载后展开到上下文中。",
+            description: "Load the full guidance document of a Skill. A Skill is pre-authored expert guidance that is expanded into the context once loaded.",
             parameters: {
                 type: "object",
                 properties: {
@@ -36,7 +36,7 @@ export function createLoadSkillTool(skillDirs, filteredSkills) {
             const skillId = input.skill_id;
             const skill = await readSkill(skillDirs, skillId);
             if (!skill) {
-                return `❌ Skill "${skillId}" 不存在，请确认名称是否正确`;
+                return `❌ Skill "${skillId}" not found, please verify the name`;
             }
             // 扫描 skill 目录下的文件列表
             let fileList = "";
@@ -46,18 +46,18 @@ export function createLoadSkillTool(skillDirs, filteredSkills) {
                     const suffix = e.isDirectory() ? "/" : "";
                     return `  - ${e.name}${suffix}`;
                 });
-                fileList = `\n\nSkill 目录文件列表：\n${files.join("\n")}`;
+                fileList = `\n\nSkill directory files:\n${files.join("\n")}`;
             }
             catch {
                 fileList = "";
             }
             return [
-                `Skill "${skillId}" 已加载：`,
+                `Skill "${skillId}" loaded:`,
                 ``,
-                `Skill 目录路径: ${skill.dirPath}`,
+                `Skill directory path: ${skill.dirPath}`,
                 fileList,
                 ``,
-                `--- Skill 内容开始 ---`,
+                `--- Skill content starts ---`,
                 skill.content,
             ].join("\n");
         },
@@ -76,16 +76,16 @@ export function createCallSkillSubAgentTool(skillDirs, filteredSkills) {
     // 只保留支持子 Agent 模式的 skill
     const subAgentSkills = filteredSkills.filter((s) => s.subAgent);
     const ids = subAgentSkills.map((s) => s.id);
-    const param = createDisclosureParam(ids, "选择一个 Skill（支持子 Agent）", EMPTY_HINT);
+    const param = createDisclosureParam(ids, "Select a Skill that supports SubAgent mode", EMPTY_HINT);
     // 拼接各 skill 的描述供 LLM 参考
     const skillDescriptions = subAgentSkills
-        .map((s) => `  - ${s.id}: ${s.description || "无描述"}`)
+        .map((s) => `  - ${s.id}: ${s.description || "No description"}`)
         .join("\n");
-    const skillIdDescription = `${param.description}\n\n各 Skill 说明：\n${skillDescriptions || "  无可用 Skill"}`;
+    const skillIdDescription = `${param.description}\n\nSkill descriptions:\n${skillDescriptions || "  No Skills available"}`;
     return new AgentToolLazy({
         function: {
             name: "call_skill_sub_agent",
-            description: "将任务委派给指定的 Skill 子 Agent，由其独立完成并返回结果。",
+            description: "Delegate a task to the specified Skill SubAgent, which completes it independently and returns the result.",
             parameters: {
                 type: "object",
                 properties: {
@@ -96,7 +96,7 @@ export function createCallSkillSubAgentTool(skillDirs, filteredSkills) {
                     },
                     task: {
                         type: "string",
-                        description: "要委派给子 Agent 完成的任务描述",
+                        description: "Task description to delegate to the SubAgent",
                     },
                 },
                 required: ["skill_id", "task"],
@@ -110,10 +110,10 @@ export function createCallSkillSubAgentTool(skillDirs, filteredSkills) {
             const task = parsedArgs.task;
             const skill = await readSkill(skillDirs, skillId);
             if (!skill) {
-                throw new Error(`❌ Skill "${skillId}" 不存在，请确认名称是否正确`);
+                throw new Error(`❌ Skill "${skillId}" not found, please verify the name`);
             }
             if (!skill.subAgent) {
-                throw new Error(`Skill "${skillId}" 不支持子 Agent 模式，请使用 load_skill 加载指导后自行处理`);
+                throw new Error(`Skill "${skillId}" does not support SubAgent mode, use load_skill to load its guidance and handle the task yourself`);
             }
             // 沿用父 Agent 的工具能力（不做权限过滤），剔除自身以防自递归
             const parentAgent = ctx.agent;

package/dist/scope/plugins/subagents/subAgentTools.js

@@ -8,7 +8,7 @@ import { createModel } from "../../../runtime/createModel.js";
  */
 export function createSubAgentTool(def, scope) {
     if (!def.function) {
-        throw new Error(`Agent "${def.id}" 没有 function 字段，不能作为 SubAgent 工具`);
+        throw new Error(`Agent "${def.id}" has no function field, so it cannot be used as a SubAgent tool`);
     }
     const selfName = def.function.name;
     const lazy = new AgentToolLazy({
@@ -33,7 +33,7 @@ export function createSubAgentTool(def, scope) {
             else {
                 const parent = ctx.agent;
                 if (!parent) {
-                    throw new Error(`SubAgent "${selfName}" 未指定 modelId，且父 Agent 没有可复用的模型`);
+                    throw new Error(`SubAgent "${selfName}" does not specify a modelId, and the parent Agent has no reusable model`);
                 }
                 client = parent.client;
                 model = parent.model;

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

@@ -74,7 +74,7 @@ async function loadToolFile(filepath, silent) {
     }
     catch (err) {
         if (!silent) {
-            getLogger().error(`[usertools] 加载工具文件失败: ${filepath} — ${err?.message ?? err}`);
+            getLogger().error(`[usertools] Failed to load tool file: ${filepath} — ${err?.message ?? err}`);
         }
         return null;
     }
@@ -110,7 +110,7 @@ function normalizeToolExport(exported, filepath, silent) {
         });
     }
     if (!silent) {
-        getLogger().error(`[usertools] 无法识别的工具格式: ${filepath}`);
+        getLogger().error(`[usertools] Unrecognized tool format: ${filepath}`);
     }
     return null;
 }

package/dist/shared/content-blocks.js

@@ -139,7 +139,7 @@ export async function fileToContentSection(input) {
     // ---- 1. 网络 URL：直接引用，不经上传/内联 ----
     if ("url" in source) {
         if (!isRemoteUrl(source.url)) {
-            throw new Error(`不支持本地 URL（${source.url}）：API 服务商无法访问。本地文件请传文件路径，而不是本地链接。`);
+            throw new Error(`Unsupported local URL (${source.url}): the API provider cannot access it. For local files pass a file path, not a local link`);
         }
         return {
             section: { type: "image_url", image_url: { url: source.url } },
@@ -160,10 +160,10 @@ export async function fileToContentSection(input) {
         absPath = path.isAbsolute(source.path) ? source.path : path.resolve(source.path);
         const st = await fs.stat(absPath);
         if (!st.isFile())
-            throw new Error(`"${absPath}" 不是文件。`);
+            throw new Error(`"${absPath}" is not a file`);
         const inferred = mimeOf(absPath);
         if (!inferred) {
-            throw new Error(`不支持的文件类型："${absPath}"（已知类型：${Object.keys(MIME_BY_EXT).join(" ")}）`);
+            throw new Error(`Unsupported file type: "${absPath}" (known types: ${Object.keys(MIME_BY_EXT).join(" ")})`);
         }
         mime = inferred;
         stat = { mtimeMs: st.mtimeMs, size: st.size };
@@ -198,10 +198,10 @@ export async function fileToContentSection(input) {
     if (isImage && model && model.vision !== true) {
         const label = absPath ?? filename;
         return {
-            section: textSection(`[图片] ${label}（当前模型不支持图片输入，如需查看请改用视觉模型）`),
+            section: textSection(`[Image] ${label} (the current model does not support image input; use a vision-capable model to view it)`),
             transport: "text",
             bytes: byteLength,
-            warning: "当前模型不支持图片输入，已退化为文本提示",
+            warning: "The current model does not support image input; degraded to a text hint",
         };
     }
     // ---- 4. 端点支持 Files API：上传（带缓存），失败降级内联 ----
@@ -231,14 +231,14 @@ export async function fileToContentSection(input) {
         catch (error) {
             if (signal?.aborted)
                 throw error;
-            warning = `上传 Files API 失败，已改为 base64 内联：${error?.message ?? error}`;
+            warning = `Files API upload failed, falling back to base64 inline: ${error?.message ?? error}`;
         }
     }
     // ---- 5. 内联（base64 data URL）----
     if (byteLength > maxInline) {
-        throw new Error(`文件体积 ${(byteLength / 1024 / 1024).toFixed(1)} MiB 超过内联上限 ` +
-            `${(maxInline / 1024 / 1024).toFixed(1)} MiB，且端点未声明 Files API 能力` +
-            `（capabilities.filesApi），无法发送。`);
+        throw new Error(`File size ${(byteLength / 1024 / 1024).toFixed(1)} MiB exceeds the inline limit of ` +
+            `${(maxInline / 1024 / 1024).toFixed(1)} MiB and the endpoint does not declare the Files API capability ` +
+            `(capabilities.filesApi), so it cannot be sent`);
     }
     // base64 来源直接透传，不重新编码（保证字节级一致，也省一次编解码）
     const dataUrl = toDataUrl(base64 ?? Buffer.from(ensureBytes()).toString("base64"), mime);

package/dist/shared/errors.js

@@ -24,9 +24,9 @@ export class ContextOverflowError extends Error {
     /** 被越过的强行阻断阈值（`tokenThresholds.guard`，绝对值） */
     guardTokens;
     constructor(promptTokens, guardTokens) {
-        super(`🛑 上下文严重超限：已用 ${promptTokens} token，超过阻断阈值 ${guardTokens}。` +
-            `当前对话可能因读入超大文件而失控，已中断，请检查并重新开始。` +
-            `（如确需更长上下文，请调高 config.json 中该模型的 tokenThresholds.guard。）`);
+        super(`🛑 Context critically over the limit: ${promptTokens} tokens used, above the blocking threshold of ${guardTokens}.` +
+            ` The conversation may have run away after reading an oversized file, so it has been interrupted — please inspect and start over.` +
+            ` (If you really need a longer context, raise tokenThresholds.guard for this model in config.json.)`);
         this.name = "ContextOverflowError";
         this.promptTokens = promptTokens;
         this.guardTokens = guardTokens;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import type { AgentNS } from "@ai-zen/agents-core";
+import type { AgentNS, AbortedMessageStrategy, AbortedToolRoundStrategy } from "@ai-zen/agents-core";
 /** 单维度权限策略：allow 或 deny 互斥 */
 export type PermissionPolicy = {
     allow: string[];
@@ -200,6 +200,27 @@ export interface AppConfig {
      * （如 read/find_text 对 300KB 文件的读取上限）。
      */
     maxToolOutput?: number;
+    /**
+     * 被中断的 assistant 消息（已输出的思考 / 正文）如何处置。
+     *
+     * - `keep`：保留已输出的部分（恢复为 `Completed`）—— 模型下一轮能接着半截往下说，
+     *   不会「失忆重来」。**出厂默认**。
+     * - `drop`：丢弃（保持 `Aborted`，不进下一轮上下文）。core 的库级默认。
+     *
+     * 只管**不带工具调用**的消息；工具轮次由 {@link abortedToolRoundStrategy} 决定。
+     * 缺省时由 `createAgent()` 回落 core 默认值（`drop`），出厂配置已写 `keep`。
+     */
+    abortedMessageStrategy?: AbortedMessageStrategy;
+    /**
+     * 被中断 / 结果不完整的工具轮次如何归一。
+     *
+     * - `fill`：保留整轮（assistant 恢复为 `Completed`，未完成的结果补原因）——**出厂默认**，
+     *   服务端要求「N 个 tool_calls 对 N 条结果」，整轮进出才不会报错。
+     * - `drop`：整轮出列（assistant 与其结果都不发给模型）。
+     *
+     * 缺省时由 `createAgent()` 回落 core 默认值（`fill`）。
+     */
+    abortedToolRoundStrategy?: AbortedToolRoundStrategy;
 }
 /**
  * 工具环境 — Scope 的能力插件在实例化内置工具时注入的环境信息。

package/package.json

@@ -1,10 +1,19 @@
 {
   "name": "@ai-zen/agents-sdk",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.23",
   "description": "AI-Zen Agents SDK — shared business logic for CLI and Desktop",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ai-zen/agents.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://github.com/ai-zen/agents/tree/main/packages/sdk#readme",
+  "bugs": {
+    "url": "https://github.com/ai-zen/agents/issues"
+  },
   "keywords": [
     "ai",
     "agent",