c0de-agent 1.13.1 → 1.14.0

package/dist/kanban/store.js

@@ -40,6 +40,16 @@ class KanbanInvalidPriorityError extends Error {
         this.value = value;
     }
 }
+/** 非有限 position（如 JSON 1e999 → Infinity）。
+ *  写入 position 列后 max(position) 恒 Infinity，后续追加卡片全部同值并列、
+ *  排序静默失效且无法自愈——入口显式拒绝。 */
+class KanbanInvalidPositionError extends Error {
+    value;
+    constructor(value) {
+        super(`position 必须为有限数字，收到 ${value}`);
+        this.value = value;
+    }
+}
 /** 卡片不存在（update/move 目标 id 无效）。 */
 class KanbanCardNotFoundError extends Error {
     cardId;
@@ -120,6 +130,32 @@ function createKanbanStore(handle, projectId) {
             .limit(1);
         return (row?.columns ?? []);
     }
+    /** 本项目的活动板 id（不懒建）：变更操作的作用域基准。无板 = 本项目无卡片。 */
+    async function currentBoardId() {
+        const [row] = await db
+            .select({ id: kanbanBoards.id })
+            .from(kanbanBoards)
+            .where(and(eq(kanbanBoards.projectId, projectId), isNull(kanbanBoards.deletedAt)))
+            .limit(1);
+        return row?.id ?? null;
+    }
+    /** 取本板卡片；不属于本板（其他项目的卡片 id / 不存在）抛 KanbanCardNotFoundError。
+     *  store 以 projectId 构造，但 update/move/delete 按卡片 id 寻址——不校验作用域时
+     *  `PATCH /api/kanban/<项目B>/cards/<项目A 的卡片 id>` 会静默改写 A 的看板
+     *  （REST 路径里的 projectId 形同虚设），删除更会直接物理删除他板卡片。 */
+    async function cardInThisBoard(id) {
+        const boardId = await currentBoardId();
+        if (!boardId)
+            throw new KanbanCardNotFoundError(id);
+        const [row] = await db
+            .select()
+            .from(kanbanCards)
+            .where(and(eq(kanbanCards.id, id), eq(kanbanCards.boardId, boardId)))
+            .limit(1);
+        if (!row)
+            throw new KanbanCardNotFoundError(id);
+        return row;
+    }
     /** 校验列存在；不存在抛 KanbanColumnNotFoundError（消息含可用列清单）。 */
     function assertColumn(columns, columnId, op) {
         if (!columns.some((c) => c.id === columnId)) {
@@ -191,6 +227,8 @@ function createKanbanStore(handle, projectId) {
         },
         async updateCard(id, patch) {
             assertPriority(patch.priority);
+            // 作用域校验：卡片必须属于本项目的板（他板卡片 id → 404 语义）。
+            const existing = await cardInThisBoard(id);
             const [row] = await db
                 .update(kanbanCards)
                 .set({
@@ -200,20 +238,18 @@ function createKanbanStore(handle, projectId) {
                 ...(patch.labels !== undefined && { labels: patch.labels }),
                 updatedAt: new Date(),
             })
-                .where(eq(kanbanCards.id, id))
+                .where(and(eq(kanbanCards.id, id), eq(kanbanCards.boardId, existing.boardId)))
                 .returning();
             if (!row)
                 throw new KanbanCardNotFoundError(id);
             return rowToCard(row);
         },
         async moveCard(id, columnId, position) {
-            const [card] = await db
-                .select({ boardId: kanbanCards.boardId })
-                .from(kanbanCards)
-                .where(eq(kanbanCards.id, id))
-                .limit(1);
-            if (!card)
-                throw new KanbanCardNotFoundError(id);
+            if (position !== undefined && !Number.isFinite(position)) {
+                throw new KanbanInvalidPositionError(position);
+            }
+            // 作用域校验（同时取回 boardId）：他板卡片 id 不得经本项目路径移动。
+            const card = await cardInThisBoard(id);
             // 悬空列校验：目标列必须存在于当前列配置，否则卡片静默不可见。
             const columns = await boardColumns(card.boardId);
             assertColumn(columns, columnId, 'move');
@@ -222,13 +258,25 @@ function createKanbanStore(handle, projectId) {
             const [row] = await db
                 .update(kanbanCards)
                 .set({ columnId, position: newPos, updatedAt: new Date() })
-                .where(eq(kanbanCards.id, id))
+                .where(and(eq(kanbanCards.id, id), eq(kanbanCards.boardId, card.boardId)))
                 .returning();
-            const moved = row;
-            return rowToCard(moved);
+            if (!row)
+                throw new KanbanCardNotFoundError(id);
+            return rowToCard(row);
         },
         async deleteCard(id) {
-            await db.delete(kanbanCards).where(eq(kanbanCards.id, id));
+            // 作用域校验 + 删除影响行数校验：他板卡片 id 与不存在的 id 都必须报错——
+            // 此前无条件 `delete where id` 恒返回成功，REST 对任何 id 都回 ok:true，
+            // 删除失败（拼错 id / 卡片已被 agent 删除）静默无反馈。
+            const boardId = await currentBoardId();
+            if (!boardId)
+                throw new KanbanCardNotFoundError(id);
+            const rows = await db
+                .delete(kanbanCards)
+                .where(and(eq(kanbanCards.id, id), eq(kanbanCards.boardId, boardId)))
+                .returning({ id: kanbanCards.id });
+            if (rows.length === 0)
+                throw new KanbanCardNotFoundError(id);
         },
         async updateBoard(patch) {
             const boardId = await getOrCreateBoardId();
@@ -315,7 +363,7 @@ function createKanbanStore(handle, projectId) {
         },
     };
 }
-export { createKanbanStore, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPriorityError, };
+export { createKanbanStore, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPositionError, KanbanInvalidPriorityError, };
 /** 把活动看板软删除进回收站（记录原项目名与工作目录）。项目行删除后 FK 将 projectId 置 null。 */
 export async function softDeleteKanbanBoard(handle, projectId, projectName, worktree) {
     const rows = await handle.db

package/dist/llm/protocols/openai-compat.d.ts

@@ -89,6 +89,13 @@ type StepState = {
     tools: ToolStreamState;
     /** Finish reason seen but not yet finalized (waiting for trailing usage chunk). */
     pendingFinish: FinishReason | null;
+    /** 已终结标记：finalize 后所有后续 chunk 一律忽略。
+     *  此前终结后未设标记——finish_reason+usage 同 chunk 完成终结后，再收到
+     *  usage-only 尾 chunk（部分 provider 在 combined chunk 之后仍补发 usage 帧）
+     *  会再次走终结分支：lifecycle 已复位，重发 step-start/step-finish/finish
+     *  （下游拿到重复 done + 重复 usage）；携带非空 content 的尾 chunk 更会
+     *  产出「完成后幻影文本」，追加进已终结的轮次。 */
+    finalized: boolean;
 };
 declare const initialStepState: () => StepState;
 /**

package/dist/llm/protocols/openai-compat.js

@@ -6,6 +6,14 @@ const joinSystem = (request) => request.system.map((p) => p.text).join('\n\n');
 const toOpenAIContent = (part) => {
     if (part.type === 'text')
         return { type: 'text', text: part.text };
+    if (part.type === 'image') {
+        // OpenAI 多模态契约：dataURL 形式的 image_url。mediaType/data 来自用户
+        // 附件（data 为无前缀 base64）——此处拼出完整 dataURL 送达模型。
+        return {
+            type: 'image_url',
+            image_url: { url: `data:${part.mediaType};base64,${part.data}` },
+        };
+    }
     return { type: 'text', text: '' };
 };
 const messageToOpenAI = (msg) => {
@@ -28,7 +36,7 @@ const messageToOpenAI = (msg) => {
     const textParts = msg.content.filter((p) => p.type === 'text');
     const toolCalls = msg.content.filter((p) => p.type === 'tool-call');
     const content = msg.role === 'user'
-        ? textParts.map(toOpenAIContent)
+        ? msg.content.filter((p) => p.type === 'text' || p.type === 'image').map(toOpenAIContent)
         : textParts.map((p) => (p.type === 'text' ? p.text : '')).join('');
     const message = {
         role: msg.role,
@@ -104,6 +112,7 @@ const initialStepState = () => ({
     lifecycle: lifecycleInitial(),
     tools: emptyTools(),
     pendingFinish: null,
+    finalized: false,
 });
 /** Map an OpenAI usage object to the internal Usage fields. */
 const mapUsage = (raw) => ({
@@ -124,11 +133,17 @@ const finalize = (lifecycle, events, reason, usage) => lifecycleFinish(lifecycle
  * trailing usage chunk triggers the finish. `done` is only true once finalized.
  */
 const step = (state, chunk) => {
+    // 终结后的 chunk 一律忽略：终结是不可逆状态，后续帧（重复 usage、
+    // 迟到 delta）不得重发 finish 事件或把文本追加进已终结的轮次。
+    if (state.finalized) {
+        return { state, events: [], done: true };
+    }
     const events = [];
     let lifecycle = state.lifecycle;
     let tools = state.tools;
     let pendingFinish = state.pendingFinish;
     let done = false;
+    let finalized = false;
     const choice = chunk.choices?.[0];
     if (choice !== undefined && choice.delta !== undefined) {
         const delta = choice.delta;
@@ -165,6 +180,7 @@ const step = (state, chunk) => {
             if (chunk.usage !== undefined) {
                 lifecycle = finalize(lifecycle, events, pendingFinish, mapUsage(chunk.usage));
                 done = true;
+                finalized = true;
                 pendingFinish = null;
             }
         }
@@ -174,9 +190,10 @@ const step = (state, chunk) => {
         const reason = pendingFinish ?? 'stop';
         lifecycle = finalize(lifecycle, events, reason, mapUsage(chunk.usage));
         done = true;
+        finalized = true;
         pendingFinish = null;
     }
-    return { state: { lifecycle, tools, pendingFinish }, events, done };
+    return { state: { lifecycle, tools, pendingFinish, finalized }, events, done };
 };
 /** Finalize a stream that ended without a trailing usage chunk (no-op if already finished). */
 const finalizeStream = (state) => {

package/dist/llm/protocols/utils/tool-stream.d.ts

@@ -20,9 +20,18 @@ type AppendOutcome = {
 };
 declare const empty: () => ToolStreamState;
 /**
- * Append a tool-call delta. If the index is new, emit a `tool-input-start`
- * (using the delta's id/name if present, else synthesized). Then emit a
- * `tool-input-delta` when an argument fragment is present.
+ * Append a tool-call delta.
+ *
+ * Identity（id/name）可能在后续 delta 才到达：部分兼容 provider 的首个
+ * tool_calls 片段只带 index 与 arguments，id/name 缺席。此前对无 id/name 的
+ * delta 整体丢弃——领先的 arguments 片段静默蒸发，工具入参被截断/损坏
+ * （JSON 解析失败或语义漂移的「执行了错误参数」）。正确语义：
+ *  1. 身份未齐时创建占位条目，片段只累积、不发事件（无 id 无法发事件）；
+ *  2. 身份到达时补发 tool-input-start + 已缓冲的 tool-input-delta，再追加
+ *     当前片段——事件顺序与参数内容完整；
+ *  3. 身份始终缺失的条目在 finishAll 静默跳过（无法映射为工具调用，
+ *     与旧的「整体丢弃」等价——空 id 的 tool call 会在下一轮触发
+ *     invalid tool_call_id）。
  */
 declare const appendOrStart: (state: ToolStreamState, delta: DeltaInput) => AppendOutcome;
 type FinishedTool = {

package/dist/llm/protocols/utils/tool-stream.js

@@ -1,41 +1,61 @@
 import { isLLMError, llmError, reasonMessage } from '../../schema/errors.js';
 const empty = () => ({});
 /**
- * Append a tool-call delta. If the index is new, emit a `tool-input-start`
- * (using the delta's id/name if present, else synthesized). Then emit a
- * `tool-input-delta` when an argument fragment is present.
+ * Append a tool-call delta.
+ *
+ * Identity（id/name）可能在后续 delta 才到达：部分兼容 provider 的首个
+ * tool_calls 片段只带 index 与 arguments，id/name 缺席。此前对无 id/name 的
+ * delta 整体丢弃——领先的 arguments 片段静默蒸发，工具入参被截断/损坏
+ * （JSON 解析失败或语义漂移的「执行了错误参数」）。正确语义：
+ *  1. 身份未齐时创建占位条目，片段只累积、不发事件（无 id 无法发事件）；
+ *  2. 身份到达时补发 tool-input-start + 已缓冲的 tool-input-delta，再追加
+ *     当前片段——事件顺序与参数内容完整；
+ *  3. 身份始终缺失的条目在 finishAll 静默跳过（无法映射为工具调用，
+ *     与旧的「整体丢弃」等价——空 id 的 tool call 会在下一轮触发
+ *     invalid tool_call_id）。
  */
 const appendOrStart = (state, delta) => {
     const current = state[delta.index];
     const events = [];
     let next;
     if (current === undefined) {
-        const id = delta.id;
-        const name = delta.name;
-        // 无效 id/name（缺失或空字符串）：丢弃该 delta 而非抛错。部分兼容
-        // provider 把 tool call 的 arguments 流式片段拆成多个独立 delta，每片
-        // id/name 为空。接受空值会产生空 id 的 tool call，导致下一轮
-        // invalid tool_call_id；抛错则让整个流崩溃。跳过最稳妥。
-        if (!id || !name) {
-            return { state, events };
-        }
-        next = { id, name, input: '', started: false };
-        const start = { type: 'tool-input-start', id, name };
-        events.push(start);
-        next.started = true;
+        next = { id: delta.id ?? '', name: delta.name ?? '', input: '', started: false };
     }
     else {
         next = { ...current };
     }
+    // 回填迟到的身份字段（已就位的字段不受后续 delta 的空值影响）
+    if (next.id === '' && delta.id)
+        next.id = delta.id;
+    if (next.name === '' && delta.name)
+        next.name = delta.name;
+    const identityReady = next.id !== '' && next.name !== '';
+    if (identityReady && !next.started) {
+        const start = { type: 'tool-input-start', id: next.id, name: next.name };
+        events.push(start);
+        next.started = true;
+        // 身份到达前已缓冲的片段按到达顺序补发
+        if (next.input.length > 0) {
+            const buffered = {
+                type: 'tool-input-delta',
+                id: next.id,
+                name: next.name,
+                text: next.input,
+            };
+            events.push(buffered);
+        }
+    }
     if (delta.argumentsDelta !== undefined && delta.argumentsDelta.length > 0) {
         next.input += delta.argumentsDelta;
-        const d = {
-            type: 'tool-input-delta',
-            id: next.id,
-            name: next.name,
-            text: delta.argumentsDelta,
-        };
-        events.push(d);
+        if (next.started) {
+            const d = {
+                type: 'tool-input-delta',
+                id: next.id,
+                name: next.name,
+                text: delta.argumentsDelta,
+            };
+            events.push(d);
+        }
     }
     return { state: { ...state, [delta.index]: next }, events };
 };
@@ -64,6 +84,10 @@ const finishAll = (state) => {
         const tool = state[Number(key)];
         if (tool === undefined)
             continue;
+        // 身份始终缺失的占位条目（appendOrStart 缓冲后 id/name 从未到达）无法
+        // 映射为工具调用——静默跳过，与旧的「整体丢弃」口径一致。
+        if (!tool.started)
+            continue;
         const end = { type: 'tool-input-end', id: tool.id, name: tool.name };
         events.push(end);
         // 解析失败不抛错：模型可能输出不完整 JSON（流被截断/提前结束）。

package/dist/llm/provider.js

@@ -41,7 +41,10 @@ const toInternalMessage = (msg) => {
     const parts = msg.content.map((p) => {
         if (p.type === 'text')
             return { type: 'text', text: p.text };
-        return { type: 'text', text: `[image: ${p.mediaType}]` };
+        // 图片数据必须送达 provider：此前降级为 `[image: <mediaType>]` 文本占位符，
+        // base64 静默丢弃——模型收到的只是一行文字，多模态能力在最后一公里失效
+        // （前端附件/持久化/token 估算全部就绪，唯独此处丢数据）。
+        return { type: 'image', mediaType: p.mediaType, data: p.data };
     });
     // assistant messages may carry tool_calls
     if (msg.role === 'assistant' && msg.toolCalls !== undefined) {
@@ -164,10 +167,22 @@ const chatStream = async function* (ctx, request, options) {
     const targets = [chain.primary, ...chain.fallbacks];
     let started = false;
     let lastError;
-    for (const target of targets) {
+    for (let i = 0; i < targets.length; i++) {
+        const target = targets[i];
         if (target === undefined)
             continue;
-        resolveRoute(ctx.registry, target.provider, target.model); // fail-fast NoRoute
+        try {
+            resolveRoute(ctx.registry, target.provider, target.model);
+        }
+        catch (error) {
+            // 主路由未注册 = 配置错误 → 快速失败；回退目标未注册（provider 被跳过注册：
+            // apiKey 跨机不可解/缺 baseURL/畸形条目）只跳过该目标——此前整条链被
+            // NoRoute 击穿，可用回退永不尝试，原始错误也被顶替。
+            if (i === 0)
+                throw error;
+            lastError = error;
+            continue;
+        }
         try {
             for await (const sc of streamTarget(ctx, request, target, chain)) {
                 started = true;

package/dist/llm/retry.d.ts

@@ -1,6 +1,7 @@
 import type { LLMErrorReason, RetryPolicy } from './schema/errors.js';
 declare const RETRY_INITIAL_DELAY = 2000;
 declare const RETRY_MAX_DELAY_NO_HEADERS = 30000;
+/** 32 位 timer 安全上限（> 此值 setTimeout 钳到 1ms）；与 shared MAX_TIMER_MS 单一来源。 */
 declare const RETRY_MAX_DELAY = 2147483647;
 /**
  * Compute the delay before the next retry attempt (ms).

package/dist/llm/retry.js

@@ -1,8 +1,10 @@
+import { MAX_TIMER_MS } from '../shared/timer.js';
 import { isLLMError, reasonRetryAfterMs, retryPolicy } from './schema/errors.js';
 const RETRY_INITIAL_DELAY = 2_000;
 const RETRY_BACKOFF_FACTOR = 2;
 const RETRY_MAX_DELAY_NO_HEADERS = 30_000;
-const RETRY_MAX_DELAY = 2_147_483_647;
+/** 32 位 timer 安全上限（> 此值 setTimeout 钳到 1ms）；与 shared MAX_TIMER_MS 单一来源。 */
+const RETRY_MAX_DELAY = MAX_TIMER_MS;
 /** Extract response headers from an LLMError's http context (if any). */
 const errorHeaders = (error) => {
     if (!isLLMError(error))
@@ -15,6 +17,14 @@ const errorHeaders = (error) => {
 };
 /** Cap a delay to the 32-bit safe ceiling. */
 const capDelay = (ms) => Math.min(ms, RETRY_MAX_DELAY);
+/** 严格解析「正有限毫秒数」：Infinity（'1e999'）/NaN/负数/零一律拒绝。
+ *  parseFloat('1e999') = Infinity 能穿过 Number.isNaN 检查——capDelay(Infinity)
+ *  后单次重试延迟 2^31ms ≈ 24.8 天，且 RateLimit 的 policy maxDelay=Infinity
+ *  不拦截，agent run 实际挂死。 */
+const parsePositiveFinite = (s) => {
+    const n = Number.parseFloat(s);
+    return Number.isFinite(n) && n > 0 ? n : null;
+};
 /**
  * Compute the delay before the next retry attempt (ms).
  * Honors retry-after / retry-after-ms headers when present, else exponential backoff
@@ -22,25 +32,28 @@ const capDelay = (ms) => Math.min(ms, RETRY_MAX_DELAY);
  */
 const delay = (attempt, error, initialDelayMs = RETRY_INITIAL_DELAY) => {
     const headers = errorHeaders(error);
+    // 无可用重试指示时统一 30s 上限退避。此前仅无 headers 路径 cap 30s——headers
+    // 存在但缺/坏 retry-after（如 500 错误携带其他头）时退避无上限，attempt=10
+    // 即膨胀到 2^9*2000 ≈ 17 分钟。
+    const backoff = () => capDelay(Math.min(initialDelayMs * RETRY_BACKOFF_FACTOR ** (attempt - 1), RETRY_MAX_DELAY_NO_HEADERS));
     if (headers) {
         const retryAfterMs = headers['retry-after-ms'];
         if (retryAfterMs !== undefined) {
-            const parsedMs = Number.parseFloat(retryAfterMs);
-            if (!Number.isNaN(parsedMs))
+            const parsedMs = parsePositiveFinite(retryAfterMs);
+            if (parsedMs !== null)
                 return capDelay(parsedMs);
         }
         const retryAfter = headers['retry-after'];
         if (retryAfter !== undefined) {
-            const parsedSeconds = Number.parseFloat(retryAfter);
-            if (!Number.isNaN(parsedSeconds))
+            const parsedSeconds = parsePositiveFinite(retryAfter);
+            if (parsedSeconds !== null)
                 return capDelay(Math.ceil(parsedSeconds * 1000));
             const parsed = Date.parse(retryAfter) - Date.now();
             if (!Number.isNaN(parsed) && parsed > 0)
                 return capDelay(Math.ceil(parsed));
         }
-        return capDelay(initialDelayMs * RETRY_BACKOFF_FACTOR ** (attempt - 1));
     }
-    return capDelay(Math.min(initialDelayMs * RETRY_BACKOFF_FACTOR ** (attempt - 1), RETRY_MAX_DELAY_NO_HEADERS));
+    return backoff();
 };
 /**
  * Decide whether a thrown error is retryable. Returns undefined when not retryable

package/dist/llm/routing.js

@@ -14,8 +14,20 @@ const runWithFallback = async (registry, chain, run) => {
         const target = targets[i];
         if (target === undefined)
             continue;
-        // Validate the route exists before attempting (fails fast with NoRoute).
-        resolveRoute(registry, target.provider, target.model);
+        try {
+            // Validate the route exists before attempting.
+            resolveRoute(registry, target.provider, target.model);
+        }
+        catch (error) {
+            // 主路由未注册 = 配置错误 → 快速失败（不静默改用回退 provider）。
+            if (i === 0)
+                throw error;
+            // 回退目标未注册（provider 因 apiKey 跨机不可解/缺 baseURL/畸形条目被跳过
+            // 注册，但 config.providers 里仍在、buildFallbackChain 照样选中）只应跳过
+            // 该目标——此前整条链被 NoRoute 击穿：可用回退永不尝试，原始错误也被顶替。
+            lastError = error;
+            continue;
+        }
         try {
             const result = await withRetry(() => run(target.provider, target.model), {
                 maxRetries: chain.maxRetries,

package/dist/llm/schema/messages.d.ts

@@ -45,7 +45,14 @@ type ToolResultPart = {
     cache?: CacheHint;
     providerMetadata?: ProviderMetadata;
 };
-type ContentPart = TextPart | ReasoningPart | ToolCallPart | ToolResultPart;
+type ImagePart = {
+    type: 'image';
+    mediaType: string;
+    /** base64 编码（不含 `data:` 前缀）。 */
+    data: string;
+    providerMetadata?: ProviderMetadata;
+};
+type ContentPart = TextPart | ReasoningPart | ToolCallPart | ToolResultPart | ImagePart;
 type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
 type Message = {
     id?: string;
@@ -93,5 +100,5 @@ type InternalRequest = {
 };
 /** Immutable patch of an InternalRequest. */
 declare const requestUpdate: (req: InternalRequest, patch: Partial<InternalRequest>) => InternalRequest;
-export type { ContentPart, InternalRequest, Message, MessageRole, ReasoningPart, ResponseFormat, SystemPart, TextPart, ToolCallPart, ToolChoice, ToolDefinition, ToolResultPart, ToolResultValue, };
+export type { ContentPart, ImagePart, InternalRequest, Message, MessageRole, ReasoningPart, ResponseFormat, SystemPart, TextPart, ToolCallPart, ToolChoice, ToolDefinition, ToolResultPart, ToolResultValue, };
 export { messageAssistant, messageSystem, messageUser, requestUpdate };

package/dist/llm/token.d.ts

@@ -1,2 +1,11 @@
+/**
+ * CJK-aware token estimate.
+ * Chinese/CJK characters ≈ 2 tokens each (denser encoding).
+ * Other characters ≈ 4 chars/token (standard heuristic).
+ *
+ * 单一权威实现：session/token 此前持有一套 CJK 感知实现、本模块持有一套
+ * 「chars/4」朴素实现，同一字符串在两处给出不同估算（中文低估 ~8 倍），
+ * 预算/压缩口径随调用点漂移——已收敛至此。
+ */
 declare const estimateTokens: (text: string) => number;
 export { estimateTokens };

package/dist/llm/token.js

@@ -1,13 +1,17 @@
 /**
- * Heuristic token estimate: ~4 characters per token for English/code text.
- * This mirrors the common "chars / 4" approximation used by tiktoken's
- * rough estimate mode. A real BPE tokenizer can be plugged in later without
- * changing this signature.
+ * CJK-aware token estimate.
+ * Chinese/CJK characters ≈ 2 tokens each (denser encoding).
+ * Other characters ≈ 4 chars/token (standard heuristic).
+ *
+ * 单一权威实现：session/token 此前持有一套 CJK 感知实现、本模块持有一套
+ * 「chars/4」朴素实现，同一字符串在两处给出不同估算（中文低估 ~8 倍），
+ * 预算/压缩口径随调用点漂移——已收敛至此。
  */
-const TOKEN_CHARS_RATIO = 4;
 const estimateTokens = (text) => {
     if (text.length === 0)
         return 0;
-    return Math.ceil(text.length / TOKEN_CHARS_RATIO);
+    const cjkCount = text.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g)?.length ?? 0;
+    const otherCount = text.length - cjkCount;
+    return Math.ceil(cjkCount * 2 + otherCount / 4);
 };
 export { estimateTokens };

package/dist/llm/transport.js

@@ -16,6 +16,9 @@ const sseFraming = async function* (stream) {
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
+            // SSE 规范允许 CRLF 行结束（部分网关/代理改写行结束符）——归一化为 LF
+            // 再分帧，否则 \r\n\r\n 分隔的事件永远匹配不到 \n\n 而滞留缓冲区。
+            buffer = buffer.replace(/\r\n/g, '\n');
             let sepIndex = buffer.indexOf('\n\n');
             while (sepIndex !== -1) {
                 const block = buffer.slice(0, sepIndex);
@@ -154,14 +157,16 @@ const classifyHttpError = (status, body, url, headers) => {
     });
 };
 const parseRetryAfterMs = (retryAfterMs, retryAfter) => {
+    // 与 retry.ts delay() 同口径：仅正有限数（'1e999' → Infinity 必须拒绝，
+    // 否则塞进 reason 后重试层延迟 2^31ms ≈ 24.8 天挂死 agent run）。
     if (retryAfterMs !== null && retryAfterMs !== undefined) {
         const parsed = Number.parseFloat(retryAfterMs);
-        if (!Number.isNaN(parsed))
+        if (Number.isFinite(parsed) && parsed > 0)
             return Math.ceil(parsed);
     }
     if (retryAfter !== null && retryAfter !== undefined) {
         const parsed = Number.parseFloat(retryAfter);
-        if (!Number.isNaN(parsed))
+        if (Number.isFinite(parsed) && parsed > 0)
             return Math.ceil(parsed * 1000);
     }
     return undefined;

package/dist/mcp/client.d.ts

@@ -0,0 +1,11 @@
+import type { MCPTransport } from './transport.js';
+type MCPClient = {
+    request: (method: string, params?: unknown, timeoutMs?: number) => Promise<unknown>;
+    notify: (method: string, params?: unknown) => void;
+    close: () => void;
+};
+/** 默认单请求超时（initialize/tools/list 用）；工具调用在调用点传更长的值。 */
+declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+declare function createMCPClient(transport: MCPTransport): MCPClient;
+export type { MCPClient };
+export { createMCPClient, DEFAULT_REQUEST_TIMEOUT_MS };

package/dist/mcp/client.js

@@ -0,0 +1,70 @@
+// MCP JSON-RPC 客户端（spec §6.1）：request/response 配对（seq id）、超时、
+// notification 无响应、连接关闭时 reject 全部 pending。协议纯逻辑，transport 注入。
+/** 默认单请求超时（initialize/tools/list 用）；工具调用在调用点传更长的值。 */
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+function createMCPClient(transport) {
+    let nextId = 1;
+    const pending = new Map();
+    const failAll = (message) => {
+        for (const p of pending.values()) {
+            if (p.timer)
+                clearTimeout(p.timer);
+            p.reject(new Error(message));
+        }
+        pending.clear();
+    };
+    transport.onMessage((msg) => {
+        if (!('id' in msg))
+            return; // 服务端通知：当前无订阅方，忽略
+        const p = pending.get(msg.id);
+        if (!p)
+            return; // 已超时/已响应/未知 id
+        pending.delete(msg.id);
+        if (p.timer)
+            clearTimeout(p.timer);
+        if (msg.error) {
+            p.reject(new Error(`MCP ${msg.error.message} (code ${msg.error.code}${msg.error.data ? `, data: ${JSON.stringify(msg.error.data)}` : ''})`));
+        }
+        else {
+            p.resolve(msg.result);
+        }
+    });
+    transport.onClose(() => {
+        failAll('MCP transport closed');
+    });
+    return {
+        request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+            const id = nextId;
+            nextId += 1;
+            const msg = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                ...(params !== undefined ? { params } : {}),
+            };
+            return new Promise((resolve, reject) => {
+                const timer = timeoutMs > 0
+                    ? setTimeout(() => {
+                        pending.delete(id);
+                        reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
+                    }, timeoutMs)
+                    : undefined;
+                pending.set(id, { resolve, reject, timer });
+                transport.send(msg);
+            });
+        },
+        notify(method, params) {
+            const msg = {
+                jsonrpc: '2.0',
+                method,
+                ...(params !== undefined ? { params } : {}),
+            };
+            transport.send(msg);
+        },
+        close() {
+            failAll('MCP client closed');
+            transport.close();
+        },
+    };
+}
+export { createMCPClient, DEFAULT_REQUEST_TIMEOUT_MS };