u1s1-cli 1.3.0 → 1.3.2

package/dist/device-auth.js

@@ -2,7 +2,14 @@ import { createHash, randomBytes, randomUUID, webcrypto } from "node:crypto";
 import { createServer } from "node:http";
 import { VERSION } from "./config.js";
 const enc = new TextEncoder();
+const SIGNING_PROXY_REQUEST_LIMIT_BYTES = 32 * 1024 * 1024;
 let cachedPrivate;
+class SigningProxyRequestTooLargeError extends Error {
+    constructor(maxBytes) {
+        super(`local signing proxy request exceeds ${maxBytes} bytes`);
+        this.name = "SigningProxyRequestTooLargeError";
+    }
+}
 function b64url(value) {
     const bytes = typeof value === "string" ? enc.encode(value) : value;
     return Buffer.from(bytes).toString("base64url");
@@ -86,7 +93,98 @@ function requestHeaders(input) {
     }
     return headers;
 }
+/** Buffer a loopback request only up to the same JSON limit enforced by Gateway. */
+export async function readSigningProxyRequestBody(request, maxBytes = SIGNING_PROXY_REQUEST_LIMIT_BYTES) {
+    const declaredLength = Number(request.headers["content-length"]);
+    if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+        throw new SigningProxyRequestTooLargeError(maxBytes);
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of request.iterator({ destroyOnReturn: false })) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += bytes.byteLength;
+        if (total > maxBytes)
+            throw new SigningProxyRequestTooLargeError(maxBytes);
+        chunks.push(bytes);
+    }
+    return chunks.length ? Buffer.concat(chunks, total) : undefined;
+}
+// Refresh once we are within a day of the server-side 7-day expiry; back off for
+// a while after a failed refresh so a flaky Gateway is not hammered per request.
+const ATTESTATION_REFRESH_MARGIN_MS = 24 * 60 * 60 * 1000;
+const ATTESTATION_REFRESH_COOLDOWN_MS = 30_000;
+// Only ever block a request while we have no token at all, and even then only
+// briefly — a Gateway too slow to answer would fail the real request anyway.
+const ATTESTATION_BLOCK_TIMEOUT_MS = 4_000;
 let signingProxy;
+function unrefDelay(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        if (typeof timer.unref === "function")
+            timer.unref();
+    });
+}
+function applyAttestation(holder, result) {
+    if (typeof result.token !== "string" || result.token.length === 0 || result.token.length > 1024)
+        return;
+    holder.token = result.token;
+    holder.expiresAtMs = typeof result.expiresInSeconds === "number" && result.expiresInSeconds > 0
+        ? Date.now() + result.expiresInSeconds * 1000
+        : undefined;
+}
+/** Seed the mutable holder from a new ensureSigningProxy call without dropping a fresher token. */
+function updateAttestationHolder(holder, source) {
+    if (!source)
+        return;
+    if (source.refresh)
+        holder.refresh = source.refresh;
+    if (source.token && !holder.token) {
+        applyAttestation(holder, { token: source.token, expiresInSeconds: source.expiresInSeconds });
+    }
+}
+/**
+ * Kick off a single-flight refresh when the token is missing or nearing expiry.
+ * Returns the in-flight refresh promise (or undefined when no refresh is due),
+ * so the caller can decide whether to wait for it.
+ */
+function ensureFreshAttestation(holder) {
+    if (!holder.refresh)
+        return undefined;
+    const now = Date.now();
+    const stale = !holder.token
+        || (holder.expiresAtMs !== undefined && now >= holder.expiresAtMs - ATTESTATION_REFRESH_MARGIN_MS);
+    if (!stale)
+        return undefined;
+    if (holder.refreshing)
+        return holder.refreshing;
+    if (holder.lastFailureMs !== undefined && now - holder.lastFailureMs < ATTESTATION_REFRESH_COOLDOWN_MS) {
+        return undefined;
+    }
+    const run = (async () => {
+        try {
+            applyAttestation(holder, await holder.refresh());
+            holder.lastFailureMs = undefined;
+        }
+        catch {
+            holder.lastFailureMs = Date.now();
+        }
+        finally {
+            holder.refreshing = undefined;
+        }
+    })();
+    holder.refreshing = run;
+    return run;
+}
+/** Attach a fresh (self-healing) attestation header to an outbound proxy request. */
+export async function attachAttestationHeader(holder, headers) {
+    const refreshing = ensureFreshAttestation(holder);
+    if (refreshing && !holder.token) {
+        await Promise.race([refreshing, unrefDelay(ATTESTATION_BLOCK_TIMEOUT_MS)]);
+    }
+    if (holder.token)
+        headers.set("x-u1s1-attestation", holder.token);
+}
 function clientSurface(fallback) {
     const explicit = process.env["U1S1_CLIENT"];
     if (explicit === "terminal" || explicit === "web" || explicit === "desktop" || explicit === "cloud") {
@@ -98,14 +196,17 @@ function clientSurface(fallback) {
  * pi accepts static provider headers only. Keep it behind a loopback proxy that
  * replaces the local bearer credential with a fresh DPoP proof per request.
  */
-export async function ensureSigningProxy(cfg, fallbackClient = "terminal", clientAttestation) {
+export async function ensureSigningProxy(cfg, fallbackClient = "terminal", attestationSource) {
     if (!hasDeviceCredential(cfg))
         throw new Error("当前安装需要重新登录，以创建设备凭证");
     const client = clientSurface(fallbackClient);
     const current = signingProxy;
-    if (current && current.token === cfg.deviceToken && current.client === client
-        && current.clientAttestation === clientAttestation)
+    if (current && current.token === cfg.deviceToken && current.client === client) {
+        updateAttestationHolder(current.attestation, attestationSource);
         return current;
+    }
+    const attestation = {};
+    updateAttestationHolder(attestation, attestationSource);
     const localKey = `local-${randomBytes(32).toString("hex")}`;
     const upstreamOrigin = new URL(cfg.baseUrl).origin;
     const server = createServer(async (req, res) => {
@@ -123,37 +224,54 @@ export async function ensureSigningProxy(cfg, fallbackClient = "terminal", clien
                 res.end(JSON.stringify({ error: { message: "signing proxy only serves /v1/*" } }));
                 return;
             }
+            const upstreamAbort = new AbortController();
+            const abortUpstream = () => {
+                if (!res.writableEnded) {
+                    upstreamAbort.abort(new Error("local signing proxy client disconnected"));
+                }
+            };
+            res.once("close", abortUpstream);
             const target = new URL(`${localUrl.pathname}${localUrl.search}`, upstreamOrigin).toString();
-            const chunks = [];
-            for await (const chunk of req)
-                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-            const body = chunks.length ? Buffer.concat(chunks) : undefined;
-            const outboundHeaders = requestHeaders(req.headers);
-            // Set these at the final local hop so model calls and extension tools share
-            // exactly the same attribution, regardless of their upstream SDK defaults.
-            outboundHeaders.set("x-u1s1-client", client);
-            outboundHeaders.set("x-u1s1-version", VERSION);
-            outboundHeaders.set("x-u1s1-platform", `${process.platform}-${process.arch}`);
-            if (clientAttestation)
-                outboundHeaders.set("x-u1s1-attestation", clientAttestation);
-            const upstream = await authorizedFetch(cfg, target, {
-                method: req.method ?? "GET",
-                headers: outboundHeaders,
-                body,
-            });
-            const headers = {};
-            upstream.headers.forEach((value, name) => {
-                if (!["content-length", "transfer-encoding", "connection"].includes(name))
-                    headers[name] = value;
-            });
-            res.writeHead(upstream.status, headers);
-            if (upstream.body) {
-                for await (const chunk of upstream.body)
-                    res.write(chunk);
+            try {
+                const body = await readSigningProxyRequestBody(req);
+                const outboundHeaders = requestHeaders(req.headers);
+                // Set these at the final local hop so model calls and extension tools share
+                // exactly the same attribution, regardless of their upstream SDK defaults.
+                outboundHeaders.set("x-u1s1-client", client);
+                outboundHeaders.set("x-u1s1-version", VERSION);
+                outboundHeaders.set("x-u1s1-platform", `${process.platform}-${process.arch}`);
+                await attachAttestationHeader(attestation, outboundHeaders);
+                const upstream = await authorizedFetch(cfg, target, {
+                    method: req.method ?? "GET",
+                    headers: outboundHeaders,
+                    body,
+                    signal: upstreamAbort.signal,
+                });
+                const headers = {};
+                upstream.headers.forEach((value, name) => {
+                    if (!["content-length", "transfer-encoding", "connection"].includes(name))
+                        headers[name] = value;
+                });
+                res.writeHead(upstream.status, headers);
+                if (upstream.body) {
+                    for await (const chunk of upstream.body)
+                        res.write(chunk);
+                }
+                res.end();
+            }
+            finally {
+                res.off("close", abortUpstream);
             }
-            res.end();
         }
         catch (error) {
+            if (error instanceof SigningProxyRequestTooLargeError && !res.destroyed) {
+                req.resume();
+                res.writeHead(413, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: { message: "local signing proxy request body is too large" } }));
+                return;
+            }
+            if (res.destroyed)
+                return;
             if (res.headersSent)
                 return void res.destroy(error);
             res.writeHead(502, { "content-type": "application/json" });
@@ -174,7 +292,7 @@ export async function ensureSigningProxy(cfg, fallbackClient = "terminal", clien
         localKey,
         token: cfg.deviceToken,
         client,
-        clientAttestation,
+        attestation,
     };
     return signingProxy;
 }

package/dist/index.js

@@ -8,7 +8,7 @@ import { registerLoopCommand } from "./loop.js";
 import { ensureSearchTools } from "./search-tools.js";
 import { ensureUsableShell } from "./shell-doctor.js";
 import { applyBrandUi, setAnnouncement, setUpdateNotice } from "./style.js";
-import { AuthError, fetchModels, loadCustomEndpoints } from "./api.js";
+import { AuthError, fetchModels, loadCustomEndpoints, readJsonResponseCapped } from "./api.js";
 import { ensureSigningProxy } from "./device-auth.js";
 const PACKAGE_NAME = "u1s1-cli";
 /** 启动时检测到的可自动安装的新版;TUI 退出后才装(见 installPendingUpdate)。 */
@@ -32,8 +32,12 @@ async function checkForUpdate() {
             signal: AbortSignal.timeout(5_000),
         });
         if (res.ok) {
-            const body = (await res.json());
-            latest = body.version;
+            const body = await readJsonResponseCapped(res, 64 * 1024);
+            latest = typeof body.version === "string"
+                && body.version.length <= 100
+                && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(body.version)
+                ? body.version
+                : undefined;
         }
     }
     catch {
@@ -193,7 +197,17 @@ async function runAgent(cfg, args) {
     // it after the live model list arrives; explicit user choices remain intact.
     ensureDefaultSettings(MODELS);
     // pi provider 只支持静态 header；指向本机 signing proxy，由它逐请求附 DPoP proof。
-    const signing = await ensureSigningProxy(cfg, "terminal", modelsResp?.clientAttestation);
+    const signing = await ensureSigningProxy(cfg, "terminal", {
+        token: modelsResp?.clientAttestation,
+        expiresInSeconds: modelsResp?.clientAttestationExpiresInSeconds,
+        refresh: async () => {
+            const refreshed = await fetchModels(cfg);
+            return {
+                token: refreshed.clientAttestation,
+                expiresInSeconds: refreshed.clientAttestationExpiresInSeconds,
+            };
+        },
+    });
     const officialCfg = { ...cfg, baseUrl: signing.baseUrl, apiKey: signing.localKey };
     ensureBrandPrompt(await shellReady);
     ensureProviderModels(officialCfg);

package/dist/login.js

@@ -1,11 +1,25 @@
 import { createRequire } from "node:module";
 import { hostname, platform } from "node:os";
-import { fetchMe } from "./api.js";
+import { fetchMe, readJsonResponseCapped } from "./api.js";
 import { printConsoleBanner } from "./brand.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { generateDeviceKeyPair, hasDeviceCredential } from "./device-auth.js";
 const require = createRequire(import.meta.url);
 const VERSION = require("../package.json").version;
+const MAX_DEVICE_AUTH_RESPONSE_BYTES = 64 * 1024;
+function boundedInteger(value, fallback, min, max) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= min && value <= max
+        ? value
+        : fallback;
+}
+function boundedCredential(value, prefix) {
+    return typeof value === "string"
+        && value.startsWith(prefix)
+        && value.length <= 4_096
+        && !/[\u0000-\u001f\u007f]/.test(value)
+        ? value
+        : null;
+}
 function tryOpenBrowser(url) {
     import("node:child_process")
         .then(({ spawn }) => {
@@ -36,16 +50,26 @@ export async function startDeviceLogin(origin) {
             }),
             signal: AbortSignal.timeout(15_000),
         });
-        if (!resp.ok)
+        if (!resp.ok) {
+            void resp.body?.cancel("device login start rejected").catch(() => { });
             return null;
-        const data = (await resp.json());
-        if (typeof data.verify_url !== "string" || typeof data.poll_secret !== "string")
+        }
+        const data = await readJsonResponseCapped(resp, MAX_DEVICE_AUTH_RESPONSE_BYTES);
+        if (typeof data.verify_url !== "string"
+            || data.verify_url.length > 2_048
+            || typeof data.poll_secret !== "string"
+            || !data.poll_secret
+            || data.poll_secret.length > 4_096
+            || /[\u0000-\u001f\u007f]/.test(data.poll_secret))
+            return null;
+        const verifyUrl = new URL(data.verify_url);
+        if (!["http:", "https:"].includes(verifyUrl.protocol) || verifyUrl.username || verifyUrl.password)
             return null;
         return {
-            verify_url: data.verify_url,
+            verify_url: verifyUrl.toString(),
             poll_secret: data.poll_secret,
-            interval: data.interval || 2,
-            expires_in: data.expires_in || 900,
+            interval: boundedInteger(data.interval, 2, 1, 30),
+            expires_in: boundedInteger(data.expires_in, 900, 1, 1_800),
             private_jwk: pair.privateJwk,
             public_jwk: pair.publicJwk,
         };
@@ -56,9 +80,11 @@ export async function startDeviceLogin(origin) {
 }
 /** 轮询等浏览器批准；只接受带设备凭证的新网关响应。outcome 可带出失败原因。 */
 export async function pollDeviceLogin(origin, start, outcome) {
-    const deadline = Date.now() + start.expires_in * 1000;
+    const interval = boundedInteger(start.interval, 2, 1, 30);
+    const expiresIn = boundedInteger(start.expires_in, 900, 1, 1_800);
+    const deadline = Date.now() + expiresIn * 1000;
     while (Date.now() < deadline) {
-        await sleep(start.interval * 1000);
+        await sleep(interval * 1000);
         try {
             const resp = await fetch(`${origin}/auth/device/poll`, {
                 method: "POST",
@@ -66,14 +92,22 @@ export async function pollDeviceLogin(origin, start, outcome) {
                 body: JSON.stringify({ poll_secret: start.poll_secret }),
                 signal: AbortSignal.timeout(10_000),
             });
-            if (!resp.ok)
+            if (!resp.ok) {
+                void resp.body?.cancel("device login poll rejected").catch(() => { });
                 continue;
-            const data = (await resp.json());
-            if (data.status === "ok" && data.api_key && data.device_token) {
+            }
+            const data = await readJsonResponseCapped(resp, MAX_DEVICE_AUTH_RESPONSE_BYTES);
+            const apiKey = boundedCredential(data.api_key, "u1s1-");
+            const deviceToken = boundedCredential(data.device_token, "u1s1d-");
+            if (data.status === "ok" && apiKey && deviceToken) {
                 return {
-                    apiKey: data.api_key,
-                    deviceToken: data.device_token,
-                    deviceId: data.device_id,
+                    apiKey,
+                    deviceToken,
+                    deviceId: typeof data.device_id === "number"
+                        && Number.isSafeInteger(data.device_id)
+                        && data.device_id > 0
+                        ? data.device_id
+                        : undefined,
                     devicePrivateJwk: start.private_jwk,
                     devicePublicJwk: start.public_jwk,
                 };

package/dist/model.d.ts

@@ -1 +1,7 @@
+import { type ModelsResponse } from "./api.js";
+import { type CliConfig } from "./config.js";
+type ModelFetcher = (cfg: CliConfig) => Promise<ModelsResponse>;
+/** Refresh official models while preserving the built-in list as an explicit offline fallback. */
+export declare function refreshOfficialModels(cfg: CliConfig, fetcher?: ModelFetcher): Promise<string | null>;
 export declare function modelCommand(nameOrAlias?: string): Promise<void>;
+export {};

package/dist/model.js

@@ -1,9 +1,28 @@
-import { loadCustomEndpoints } from "./api.js";
-import { CUSTOM_ENDPOINTS, findModel, loadConfig, MODELS, persistPreferredModel, PROVIDER_ID, resolvePreferredModel, } from "./config.js";
+import { fetchModels, loadCustomEndpoints } from "./api.js";
+import { apiModelToDef, CUSTOM_ENDPOINTS, findModel, loadConfig, MODELS, persistPreferredModel, PROVIDER_ID, resolvePreferredModel, setModelsFromApi, } from "./config.js";
+/** Refresh official models while preserving the built-in list as an explicit offline fallback. */
+export async function refreshOfficialModels(cfg, fetcher = fetchModels) {
+    try {
+        const { models } = await fetcher(cfg);
+        if (models.length === 0)
+            return "线上模型列表为空";
+        setModelsFromApi(models.map(apiModelToDef));
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 export async function modelCommand(nameOrAlias) {
     const cfg = loadConfig();
-    // 云端可能刚改过端点配置;拉一次(失败回退本地缓存),再解析当前默认
-    await loadCustomEndpoints(cfg);
+    // Fetch both live catalogues before resolving the persisted default.
+    const [officialModelsError] = await Promise.all([
+        refreshOfficialModels(cfg),
+        loadCustomEndpoints(cfg),
+    ]);
+    if (officialModelsError) {
+        console.error(`  获取线上模型列表失败，使用内置列表：${officialModelsError}`);
+    }
     const current = resolvePreferredModel(cfg);
     if (!nameOrAlias) {
         console.log("");
@@ -26,7 +45,7 @@ export async function modelCommand(nameOrAlias) {
             }
         }
         console.log("");
-        console.log("  切换:u1s1 model grok / u1s1 model deepseek(对话里 /model 同样会记住)");
+        console.log("  切换:u1s1 model <model-id>(对话里 /model 同样会记住)");
         if (CUSTOM_ENDPOINTS.length) {
             console.log("  端点模型重名时可加限定:u1s1 model 端点名:模型id");
         }

package/dist/search-tools.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { chmodSync, createWriteStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "node:fs";
 import { arch, platform } from "node:os";
 import { join } from "node:path";
-import { Readable } from "node:stream";
+import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { agentDir } from "./config.js";
 /**
@@ -24,6 +24,7 @@ const TOOLS = [
 ];
 const binDir = join(agentDir, "bin");
 const DOWNLOAD_TIMEOUT_MS = 60_000;
+const MAX_TOOL_ARCHIVE_BYTES = 64 * 1024 * 1024;
 function archStr() {
     const a = arch();
     return a === "arm64" ? "aarch64" : a === "x64" ? "x86_64" : null;
@@ -110,11 +111,23 @@ async function install(tool, baseUrl, binName) {
     });
     if (!res.ok || !res.body)
         throw new Error(`HTTP ${res.status}`);
+    const declaredLength = Number(res.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > MAX_TOOL_ARCHIVE_BYTES) {
+        void res.body.cancel("tool archive exceeded limit").catch(() => { });
+        throw new Error(`下载文件超过 ${MAX_TOOL_ARCHIVE_BYTES} bytes`);
+    }
     const archive = join(binDir, asset);
     // fd/rg 并行安装,解压目录按工具名+pid 隔离,避免互踩
     const extractDir = join(binDir, `preseed_${tool.bin}_${process.pid}`);
     try {
-        await pipeline(Readable.fromWeb(res.body), createWriteStream(archive));
+        let received = 0;
+        const limiter = new Transform({
+            transform(chunk, _encoding, callback) {
+                received += chunk.byteLength;
+                callback(received > MAX_TOOL_ARCHIVE_BYTES ? new Error("tool archive exceeded limit") : null, received > MAX_TOOL_ARCHIVE_BYTES ? undefined : chunk);
+            },
+        });
+        await pipeline(Readable.fromWeb(res.body), limiter, createWriteStream(archive));
         mkdirSync(extractDir, { recursive: true });
         if (!extract(archive, extractDir))
             throw new Error(`解压失败 ${asset}`);

package/dist/subagent.d.ts

@@ -30,6 +30,19 @@ export interface SubagentOutcome {
     text: string;
     usage: SubagentUsage;
 }
+type PromptSession = {
+    prompt(task: string): Promise<void>;
+    abort(): Promise<void>;
+};
+/**
+ * Run one prompt while preserving the reason that stopped it. AgentSession.abort()
+ * resolves the active prompt normally, so the caller must not infer success merely
+ * because prompt() settled after a timeout or parent cancellation.
+ */
+export declare function promptSubagentSession(session: PromptSession, task: string, options: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<void>;
 /**
  * Spawn 一个独立上下文的子 agent 执行任务,返回其最终文本输出。
  * 模型解析:"provider/id" 精确匹配;裸 id(如 deepseek-v4-flash)先按原样找,
@@ -47,3 +60,4 @@ export declare function runPool<T>(input: {
     run: (item: T, index: number) => Promise<void>;
     signal?: AbortSignal;
 }): Promise<void>;
+export {};

package/dist/subagent.js

@@ -6,6 +6,45 @@ export const SUBAGENT_CONCURRENCY = 4;
 export const SUBAGENT_TIMEOUT_MS = 15 * 60_000;
 /** ModelRuntime 进程内只建一次(auth/models 解析有启动开销)。 */
 let sharedModelRuntime;
+function cancelledError(signal) {
+    return new Error("已取消", { cause: signal.reason });
+}
+/**
+ * Run one prompt while preserving the reason that stopped it. AgentSession.abort()
+ * resolves the active prompt normally, so the caller must not infer success merely
+ * because prompt() settled after a timeout or parent cancellation.
+ */
+export async function promptSubagentSession(session, task, options) {
+    if (options.signal?.aborted)
+        throw cancelledError(options.signal);
+    let timedOut = false;
+    let promptError;
+    const abortSession = () => {
+        void session.abort().catch(() => { });
+    };
+    const timer = setTimeout(() => {
+        timedOut = true;
+        abortSession();
+    }, options.timeoutMs);
+    const onParentAbort = abortSession;
+    options.signal?.addEventListener("abort", onParentAbort, { once: true });
+    try {
+        await session.prompt(task);
+    }
+    catch (error) {
+        promptError = error;
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onParentAbort);
+    }
+    if (options.signal?.aborted)
+        throw cancelledError(options.signal);
+    if (timedOut)
+        throw new Error(`子任务超时(${options.timeoutMs}ms)`, { cause: promptError });
+    if (promptError)
+        throw promptError;
+}
 /** 从会话消息里取最后一条非空 assistant 文本作为子 agent 的最终输出。 */
 function extractFinalText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -59,6 +98,8 @@ function extractUsage(messages, model) {
  * 失败(模型错误/超时/取消)抛错,由调用方决定容错语义。
  */
 export async function runSubagent(opts) {
+    if (opts.signal?.aborted)
+        throw cancelledError(opts.signal);
     sharedModelRuntime ??= await ModelRuntime.create();
     let model;
     if (opts.model) {
@@ -98,22 +139,17 @@ export async function runSubagent(opts) {
         ...(model ? { model } : {}),
         ...(opts.noTools ? { noTools: "all" } : {}),
     });
-    const timeoutMs = opts.timeoutMs ?? SUBAGENT_TIMEOUT_MS;
-    const timer = setTimeout(() => void session.abort(), timeoutMs);
-    const onParentAbort = () => void session.abort();
-    opts.signal?.addEventListener("abort", onParentAbort, { once: true });
     try {
-        await session.prompt(opts.task);
+        await promptSubagentSession(session, opts.task, {
+            timeoutMs: opts.timeoutMs ?? SUBAGENT_TIMEOUT_MS,
+            signal: opts.signal,
+        });
+        const messages = session.messages;
+        return { ok: true, text: extractFinalText(messages), usage: extractUsage(messages, model) };
     }
     finally {
-        clearTimeout(timer);
-        opts.signal?.removeEventListener("abort", onParentAbort);
         session.dispose();
     }
-    if (opts.signal?.aborted)
-        throw new Error("已取消");
-    const messages = session.messages;
-    return { ok: true, text: extractFinalText(messages), usage: extractUsage(messages, model) };
 }
 /**
  * 固定并发的工作池:limit 个工人依次领任务跑完一个补位一个。

package/dist/tools.d.ts

@@ -3,6 +3,8 @@ import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { CliConfig } from "./config.js";
 export declare function truncate(text: string): string;
+/** 只下载前 maxBytes 就断流,超大页面不用整个拉完再丢。 */
+export declare function readBodyCapped(resp: Response, maxBytes: number): Promise<Uint8Array>;
 /** 联网工具通用渲染:调用行不占位,收起时只显一行摘要,ctrl+o 展开全文,出错显一行 ✗ */
 export declare function compactResultRender(input: {
     result: {
@@ -43,6 +45,8 @@ export declare function downloadGeneratedImage(url: string, signal: AbortSignal,
     attempts?: number;
     retryDelayMs?: number;
     fetchImpl?: typeof fetch;
+    maxBytes?: number;
+    attemptTimeoutMs?: number;
 }): Promise<Uint8Array>;
 /** 生图工具:走 u1s1 网关代理火山方舟 Seedream,上游 key 不落到用户机器上。 */
 export declare function createImageTool(cfg: Pick<CliConfig, "baseUrl" | "apiKey">): import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
@@ -54,6 +58,10 @@ export declare function createImageTool(cfg: Pick<CliConfig, "baseUrl" | "apiKey
     path: string;
     size: string | null;
     bytes: number;
+    displayImage: {
+        data: string;
+        mimeType: string;
+    };
 }, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;
 export interface FetchToolConfig {
     baseUrl: string;