pi-web-ui 0.94.0 → 0.95.0

package/dist/server/attachments.js

@@ -1,7 +1,8 @@
-import { countLines, decodeText, looksLikeText, sniffImageMime } from "./text-sniff.js";
+import { sniffImageMime } from "./text-sniff.js";
 import { saveUpload, uploadsRoot } from "./uploads.js";
 import { isAbsoluteWirePath, wireToAbs } from "./files-service.js";
 import { buildVisionBridgePrompt, findVisionModels, transcribeImages } from "./vision-bridge.js";
+import { saveAttachment } from "./attachment-store.js";
 /** 跨快照的视觉转写缓存：批次 hash（名称 + base64 头 + 提示词）→ 转写文本。
  *  编辑重问重发相同图片不再重复耗视觉 token。进程级共享即可。 */
 const visionBridgeCache = new Map();
@@ -25,9 +26,6 @@ export async function buildAttachmentMessages(ctx, attachments) {
     const { resolve, sep, relative, extname, basename } = await import("node:path");
     const root = resolve(ctx.cwd);
     const MAX_ATTACHMENT_BYTES = 200 * 1024;
-    // Files at or below this size are inlined; larger files are referenced by
-    // path only (the model reads them on demand — saves tokens for small edits).
-    const MAX_INLINE_BYTES = Number(process.env.PI_WEB_INLINE_FILE_MAX ?? 12 * 1024);
     const IMAGE_EXT = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
     const MIME = {
         ".png": "image/png",
@@ -40,55 +38,30 @@ export async function buildAttachmentMessages(ctx, attachments) {
     };
     const out = [];
     /** Push the aside for a raw uploaded file (fresh fileData or a restored
-     *  uploadPath re-read from disk). Small text files are inlined so the
-     *  model sees them immediately; everything else becomes a path reference.
+     *  uploadPath re-read from disk). Uploads are NEVER inlined: the model gets
+     *  the persisted absolute path and reads it on demand with its read tool.
      *  `upload: true` marks the card as a restorable upload — the browser
      *  re-sends it by path when editing & re-asking a question. */
     const pushUploadAside = (name, wirePath, buf) => {
-        if (buf.length <= MAX_INLINE_BYTES && looksLikeText(buf)) {
-            const lines = countLines(buf);
-            out.push({
-                message: {
-                    customType: "file",
-                    content: [
-                        {
-                            type: "text",
-                            text: `\n<file path="${wirePath}">\n\`\`\`\n${decodeText(buf)}\n\`\`\`\n</file>`,
-                        },
-                    ],
-                    display: true,
-                    details: {
-                        name,
-                        path: wirePath,
-                        mode: "inline",
-                        size: buf.length,
-                        lines,
-                        upload: true,
-                    },
-                },
-            });
-        }
-        else {
-            out.push({
-                message: {
-                    customType: "file",
-                    content: [
-                        {
-                            type: "text",
-                            text: `<file path="${wirePath}" size="${buf.length}" />`,
-                        },
-                    ],
-                    display: true,
-                    details: {
-                        name,
-                        path: wirePath,
-                        mode: "reference",
-                        size: buf.length,
-                        upload: true,
+        out.push({
+            message: {
+                customType: "file",
+                content: [
+                    {
+                        type: "text",
+                        text: `<file path="${wirePath}" size="${buf.length}" />`,
                     },
+                ],
+                display: true,
+                details: {
+                    name,
+                    path: wirePath,
+                    mode: "reference",
+                    size: buf.length,
+                    upload: true,
                 },
-            });
-        }
+            },
+        });
     };
     // -- Vision bridge ------------------------------------------------------
     // When the active model can't accept images (DeepSeek, GLM, …), pasted
@@ -244,8 +217,6 @@ export async function buildAttachmentMessages(ctx, attachments) {
             }
         }
     }
-    /** Cap for reading a file in "lines" mode (selected slice is inlined). */
-    const MAX_LINES_READ_BYTES = 2 * 1024 * 1024;
     for (const [idx, att] of attachments.entries()) {
         // Quoted conversation (left-panel right-click / global-search quote):
         // `path` is unused — the reference travels in conversationId (running
@@ -343,6 +314,16 @@ export async function buildAttachmentMessages(ctx, attachments) {
                 });
                 continue;
             }
+            let attachmentUrl;
+            let attachmentHash;
+            try {
+                const rec = await saveAttachment(Buffer.from(raw, "base64"), mimeType);
+                attachmentUrl = rec.url;
+                attachmentHash = rec.hash;
+            }
+            catch {
+                /* CAS 保存失败不阻断流程 */
+            }
             const transcript = bridgeTranscripts.get(idx);
             if (transcript) {
                 // Bridged: the text-only main model can't see images, so it gets the
@@ -356,7 +337,12 @@ export async function buildAttachmentMessages(ctx, attachments) {
                                 type: "text",
                                 text: `\n<vision-bridge>\n${transcript}\n</vision-bridge>`,
                             },
-                            { type: "image", data: raw, mimeType },
+                            {
+                                type: "image",
+                                data: raw,
+                                mimeType,
+                                ...(attachmentUrl ? { source: { type: "url", url: attachmentUrl } } : {}),
+                            },
                         ],
                         display: true,
                         details: {
@@ -364,6 +350,8 @@ export async function buildAttachmentMessages(ctx, attachments) {
                             path: undefined,
                             mode: "bridged",
                             size: bytes,
+                            attachmentUrl,
+                            attachmentHash,
                         },
                     },
                 });
@@ -372,7 +360,14 @@ export async function buildAttachmentMessages(ctx, attachments) {
             out.push({
                 message: {
                     customType: "file",
-                    content: [{ type: "image", data: raw, mimeType }],
+                    content: [
+                        {
+                            type: "image",
+                            data: raw,
+                            mimeType,
+                            ...(attachmentUrl ? { source: { type: "url", url: attachmentUrl } } : {}),
+                        },
+                    ],
                     display: true,
                     details: {
                         name: att.name ?? "image.png",
@@ -380,6 +375,8 @@ export async function buildAttachmentMessages(ctx, attachments) {
                         path: undefined,
                         mode: "image",
                         size: bytes,
+                        attachmentUrl,
+                        attachmentHash,
                     },
                 },
             });
@@ -388,9 +385,7 @@ export async function buildAttachmentMessages(ctx, attachments) {
         // Raw uploaded file (base64) — no workspace path involved. The bytes are
         // persisted under <dataDir>/uploads/<clientId>/ so the model can read
         // them on demand with its read tool (absolute path, no traversal guard
-        // needed — the path is server-generated). Small text uploads are inlined
-        // so the model sees them immediately; everything else becomes a path
-        // reference.
+        // needed — the path is server-generated). Always a path reference.
         if (att.fileData) {
             const buf = Buffer.from(att.fileData, "base64");
             const MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
@@ -601,6 +596,7 @@ ${transcript}
             });
             continue;
         }
+        /** Path-only aside — no file content is read or injected. */
         const makeReference = () => ({
             message: {
                 customType: "file",
@@ -614,36 +610,12 @@ ${transcript}
                 details: { name, path: rel, mode: "reference", size: stat.size },
             },
         });
-        const makeInline = (buf) => {
-            const lines = countLines(buf);
-            return {
-                message: {
-                    customType: "file",
-                    content: [
-                        {
-                            type: "text",
-                            text: `\n<file path="${rel}">\n\`\`\`\n${decodeText(buf)}\n\`\`\`\n</file>`,
-                        },
-                    ],
-                    display: true,
-                    details: {
-                        name,
-                        path: rel,
-                        mode: "inline",
-                        size: stat.size,
-                        lines,
-                    },
-                },
-            };
-        };
-        // Reference mode is always honored and never reads the file.
-        if (att.mode === "reference") {
-            out.push(makeReference());
-            continue;
-        }
-        // Line-range mode: inline only the selected 1-based inclusive range.
-        // Reading is capped so a huge file can't exhaust memory even though
-        // the selected slice is small.
+        // Everything else is a PATH REFERENCE: the file content is never injected
+        // into the prompt (small files included) — the model reads what it needs
+        // with its own read tool (built-in truncation/pagination).
+        // Line-range mode adds the `lines` attribute so the model knows which
+        // slice the user picked and only reads that part.
+        // A legacy `mode: "inline"` (old client / persisted draft) lands here too.
         if (att.mode === "lines") {
             const range = att.lines;
             if (!range || range.start < 1 || range.end < range.start) {
@@ -656,52 +628,13 @@ ${transcript}
                 out.push(makeReference());
                 continue;
             }
-            if (stat.size > MAX_LINES_READ_BYTES) {
-                ctx.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `文件过大，已改为仅引用：${att.path}`,
-                    textEn: `File too large, switched to reference-only: ${att.path}`,
-                });
-                out.push(makeReference());
-                continue;
-            }
-            const buf = await fs.readFile(abs);
-            if (buf.includes(0)) {
-                ctx.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `二进制文件已改为仅引用：${att.path}`,
-                    textEn: `Binary file, switched to reference-only: ${att.path}`,
-                });
-                out.push(makeReference());
-                continue;
-            }
-            const parts = decodeText(buf).split("\n");
-            // A trailing newline yields an empty phantom line — drop it so line
-            // numbers match the preview panel.
-            if (parts.length > 0 && parts[parts.length - 1] === "")
-                parts.pop();
-            const start = Math.min(range.start, parts.length);
-            const end = Math.min(range.end, parts.length);
-            if (start < 1 || end < start) {
-                ctx.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `选中行超出文件范围，已改为仅引用：${att.path}`,
-                    textEn: `Selected lines out of range, switched to reference-only: ${att.path}`,
-                });
-                out.push(makeReference());
-                continue;
-            }
-            const selected = parts.slice(start - 1, end).join("\n");
             out.push({
                 message: {
                     customType: "file",
                     content: [
                         {
                             type: "text",
-                            text: `\n<file path="${rel}" lines="${start}-${end}">\n\`\`\`\n${selected}\n\`\`\`\n</file>`,
+                            text: `<file path="${rel}" lines="${range.start}-${range.end}" size="${stat.size}" />`,
                         },
                     ],
                     display: true,
@@ -710,57 +643,15 @@ ${transcript}
                         path: rel,
                         mode: "lines",
                         size: stat.size,
-                        lines: end - start + 1,
-                        startLine: start,
-                        endLine: end,
+                        lines: range.end - range.start + 1,
+                        startLine: range.start,
+                        endLine: range.end,
                     },
                 },
             });
             continue;
         }
-        // Forced inline has a hard cap to protect the model context.
-        if (att.mode === "inline") {
-            if (stat.size > MAX_INLINE_BYTES) {
-                ctx.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `文件过大，已改为仅引用：${att.path}`,
-                    textEn: `File too large, switched to reference-only: ${att.path}`,
-                });
-                out.push(makeReference());
-                continue;
-            }
-            const buf = await fs.readFile(abs);
-            if (buf.includes(0)) {
-                ctx.emit({
-                    type: "notice",
-                    level: "warning",
-                    text: `二进制文件已改为仅引用：${att.path}`,
-                    textEn: `Binary file, switched to reference-only: ${att.path}`,
-                });
-                out.push(makeReference());
-                continue;
-            }
-            out.push(makeInline(buf));
-            continue;
-        }
-        // Auto: small files inline, large files reference by path.
-        if (stat.size > MAX_INLINE_BYTES) {
-            out.push(makeReference());
-            continue;
-        }
-        const buf = await fs.readFile(abs);
-        if (buf.includes(0)) {
-            ctx.emit({
-                type: "notice",
-                level: "warning",
-                text: `二进制文件已跳过（仅引用路径）：${att.path}`,
-                textEn: `Binary file skipped (path referenced only): ${att.path}`,
-            });
-            out.push(makeReference());
-            continue;
-        }
-        out.push(makeInline(buf));
+        out.push(makeReference());
     }
     return out;
 }

package/dist/server/client-state.js

@@ -474,8 +474,10 @@ export class ClientStateStore {
                 : (stored?.terminalToolsEnabled ?? false),
             terminalBash: stored?.terminalBash ?? false,
             terminalBashIdleMs: stored?.terminalBashIdleMs ?? 15_000,
+            terminalBashMaxForegroundMs: stored?.terminalBashMaxForegroundMs ?? 60_000,
             toolWatchdogTimeoutMs: normalizeToolWatchdogTimeoutMs(stored?.toolWatchdogTimeoutMs),
             readDirEnabled: stored?.readDirEnabled ?? true,
+            toolApprovalEnabled: stored?.toolApprovalEnabled ?? true,
             editSoftEnabled: stored?.disabledAgentTools !== undefined
                 ? deriveLegacy(legacyToDisabled(stored)).editSoftEnabled
                 : (stored?.editSoftEnabled ?? false),
@@ -531,8 +533,10 @@ export class ClientStateStore {
             terminalToolsEnabled: settings.terminalToolsEnabled ?? cur.terminalToolsEnabled ?? false,
             terminalBash: settings.terminalBash ?? cur.terminalBash ?? false,
             terminalBashIdleMs: settings.terminalBashIdleMs ?? cur.terminalBashIdleMs ?? 15_000,
+            terminalBashMaxForegroundMs: settings.terminalBashMaxForegroundMs ?? cur.terminalBashMaxForegroundMs ?? 60_000,
             toolWatchdogTimeoutMs: normalizeToolWatchdogTimeoutMs(settings.toolWatchdogTimeoutMs ?? cur.toolWatchdogTimeoutMs ?? DEFAULT_TOOL_WATCHDOG_TIMEOUT_MS),
             readDirEnabled: settings.readDirEnabled ?? cur.readDirEnabled ?? true,
+            toolApprovalEnabled: settings.toolApprovalEnabled ?? cur.toolApprovalEnabled ?? true,
             editSoftEnabled: settings.editSoftEnabled ?? cur.editSoftEnabled ?? false,
             questionnaireEnabled: settings.questionnaireEnabled ?? cur.questionnaireEnabled ?? true,
             goalModeEnabled: settings.goalModeEnabled ?? cur.goalModeEnabled ?? true,

package/dist/server/compact-context-tool.js

@@ -0,0 +1,125 @@
+// ---------------------------------------------------------------------------
+// compact-context-tool.ts — 主动压缩上下文工具（compact_context）
+// ---------------------------------------------------------------------------
+// 让 AI 可以根据当前问题主动触发上下文压缩，自主决定保留和当前问题相关的内容，
+// 去除或深度压缩与当前问题无关、弱相关的历史探索与冗余输出。
+//
+// 执行时机：当 AI 在当前回合调用本工具后，本工具记录 pending 压缩请求并返回成功；
+// 在当前回合结束后（agent_settled 时会话处于完全 idle 状态），系统自动应用 AI
+// 指定的保留范围（keepRecentTokens）与关注点（focus / summary），执行 SDK 的
+// context compaction，使精炼后的上下文在后续交互中持续生效。
+// ---------------------------------------------------------------------------
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { bilingual, pick } from "./i18n.js";
+import { COMPACT_CONTEXT_TOOL_NAME } from "./tool-manager.js";
+/** 工具名（唯一登记在 tool-manager.ts，在此 re-export 供外部模块引用）。 */
+export { COMPACT_CONTEXT_TOOL_NAME };
+/** 最小允许保留近期 tokens 下限。 */
+export const MIN_KEEP_RECENT_TOKENS = 1000;
+/** 最大允许保留近期 tokens 上限。 */
+export const MAX_KEEP_RECENT_TOKENS = 100000;
+/** SDK 默认的常规保留 tokens。 */
+export const DEFAULT_KEEP_RECENT_TOKENS = 20000;
+/**
+ * 智能计算生效的 keepRecentTokens：
+ * - 若 AI 显式指定，钳制到合法区间 [MIN_KEEP_RECENT_TOKENS, MAX_KEEP_RECENT_TOKENS]；
+ * - 若未显式指定，根据当前会话估算 tokens 动态计算：
+ *   会话较大时（>= 30000）保留默认 20000 tokens；
+ *   会话中等或较小时（< 30000），保留最近约 35%（且不低于 1500 tokens），
+ *   确保即便会话只有数千 tokens 时，也能成功切出前半段历史进行压缩，避免报 session too small。
+ * 纯函数。
+ */
+export function calculateEffectiveKeepRecentTokens(requestedTokens, currentEstimatedTokens) {
+    if (typeof requestedTokens === "number" && Number.isFinite(requestedTokens)) {
+        return Math.min(MAX_KEEP_RECENT_TOKENS, Math.max(MIN_KEEP_RECENT_TOKENS, Math.floor(requestedTokens)));
+    }
+    const current = Math.max(0, currentEstimatedTokens ?? 0);
+    if (current >= 30000) {
+        return DEFAULT_KEEP_RECENT_TOKENS;
+    }
+    if (current > 0) {
+        // 动态保留约 35%，至少保留 1500 tokens，上限不超过 DEFAULT_KEEP_RECENT_TOKENS
+        const dynamicTokens = Math.max(1500, Math.floor(current * 0.35));
+        return Math.min(DEFAULT_KEEP_RECENT_TOKENS, dynamicTokens);
+    }
+    return DEFAULT_KEEP_RECENT_TOKENS;
+}
+/**
+ * 组装给 SDK compaction 的完整指示文本：
+ * 融入 focus 指示与 AI 自主提炼的 customSummary。纯函数。
+ */
+export function buildCompactionInstructions(focus, customSummary) {
+    const trimmedFocus = focus.trim();
+    const trimmedSummary = customSummary?.trim();
+    if (!trimmedSummary)
+        return trimmedFocus;
+    return `${trimmedFocus}\n\n[Key Points / Summary to Retain]\n${trimmedSummary}`;
+}
+export const CompactContextParams = Type.Object({
+    focus: Type.String({
+        description: "Specific focus and requirements for context compaction based on the current issue or task. Clearly specify: 1) The active problem/goal being solved; 2) Crucial context to PRESERVE (key architectural decisions, code changes, conventions, user constraints); 3) Distractions or historical details to REMOVE or aggressively condense (failed attempts, resolved debugging outputs, off-topic discussions).\n根据当前问题/任务制定的上下文压缩重点。请指明：1) 当前正在解决的核心任务或问题；2) 必须保留的核心上下文（架构决策、已确认修改、约定规范等）；3) 应当丢弃或极简概括的无关历史（错误尝试、冗长排查、其他不相关讨论等）。",
+    }),
+    keepRecentTokens: Type.Optional(Type.Number({
+        description: "Optional scope of recent tokens to keep uncompacted (e.g. 1000 - 64000). Smaller values (e.g. 3000-8000) compact more aggressively, retaining only immediate context. Larger values retain more recent history. If omitted, the system automatically calculates a reasonable retention scope based on session size.\n可选的近期不压缩保留 token 范围（1000 - 64000）。较小值（如 3000-8000）压缩更彻底，只保留紧贴当前的上下文；较大值保留更多近期操作。不传时系统会根据当前会话规模自动计算合理的保留范围。",
+    })),
+    summary: Type.Optional(Type.String({
+        description: "Optional custom structured summary text written directly by you. If provided, this summary will be used as the core basis for the compaction entry.\n可选由你自主直接编写的精炼结构化摘要正文。若提供，系统将以此摘要为核心作为压缩总结。",
+    })),
+});
+export function makeCompactContextTool(host, lang) {
+    const getLang = lang ?? (() => "en");
+    return defineTool({
+        name: COMPACT_CONTEXT_TOOL_NAME,
+        label: "Compact conversation context based on current issue",
+        description: bilingual("Compress/compact the conversation context based on the current task or problem. You can specify what context to preserve (key decisions, code structure, requirements related to the current issue) and what to drop or summarize heavily (unrelated explorations, verbose tool outputs, resolved debugging steps). You can also control the compaction scope by setting how many recent tokens to keep untouched. Compaction executes when the current turn/run settles, refreshing the context for subsequent turns.", "根据当前任务或问题主动压缩上下文。你可以自主指定需要保留的关键信息（与当前问题相关的决策、代码结构、核心规范）以及需要丢弃或深度压缩的无关内容（无关探索、冗长输出、已解决的历史排查）。还可以通过指定保留最近的 token 数量来控制压缩范围。压缩将在本轮结束后立即执行，并在后续对话中生效。"),
+        promptSnippet: "proactively compact conversation context focusing on the current issue",
+        promptGuidelines: [
+            "Use compact_context when the conversation has grown long, or after extensive debugging/exploration, to focus context strictly on the current problem.",
+            "Clearly specify in 'focus' what to keep (decisions, specs, active changes) and what to drop (failed attempts, voluminous command outputs).",
+            "After calling compact_context, conclude your current turn with a brief wrap-up and next steps; the system executes compaction right after this turn finishes.",
+        ],
+        parameters: CompactContextParams,
+        execute: async (_id, p) => {
+            const l = getLang();
+            const params = p;
+            const focus = params.focus?.trim() || "";
+            if (!focus) {
+                const errMsg = pick(l, "调用 compact_context 必须提供 focus 参数，说明针对当前问题的压缩要求与保留重点。", "compact_context requires a 'focus' parameter explaining what to keep and what to drop for the current issue.");
+                return {
+                    content: [{ type: "text", text: errMsg }],
+                    details: { ok: false, error: errMsg },
+                    isError: true,
+                };
+            }
+            const stats = host.getContextStats();
+            // 如果整个会话消息条数太少（< 4 条）且 token 极少（< 1200），无需压缩
+            if (stats.messageCount < 4 && stats.estimatedTokens < 1200) {
+                const msg = pick(l, `当前会话历史较短（约 ${stats.estimatedTokens} tokens，${stats.messageCount} 条消息），无需压缩。建议在历史累积较长或切换任务焦点后再调用此工具。`, `Current conversation is very brief (~${stats.estimatedTokens} tokens, ${stats.messageCount} messages), no compaction needed yet. Call this tool when history grows longer or when switching task focus.`);
+                return {
+                    content: [{ type: "text", text: msg }],
+                    details: { ok: false, skipped: true, ...stats },
+                };
+            }
+            const effectiveKeepTokens = calculateEffectiveKeepRecentTokens(params.keepRecentTokens, stats.estimatedTokens);
+            const pending = {
+                focus,
+                keepRecentTokens: effectiveKeepTokens,
+                summary: params.summary?.trim() || undefined,
+                requestedAt: Date.now(),
+            };
+            host.scheduleCompaction(pending);
+            const successMsg = pick(l, `已成功登记上下文压缩请求。将在本轮回复结束后立即执行上下文压缩。\n- 压缩聚焦点：${focus}\n- 保留近期范围：~${effectiveKeepTokens.toLocaleString()} tokens${pending.summary ? "\n- 包含自主提炼的摘要正文" : ""}\n请在结束本轮回复后，在精炼后的上下文中继续后续工作。`, `Context compaction request scheduled. It will execute immediately after the current turn ends.\n- Focus: ${focus}\n- Retain scope: ~${effectiveKeepTokens.toLocaleString()} tokens${pending.summary ? "\n- Custom summary provided" : ""}\nPlease wrap up this turn, and continue work in the compacted context.`);
+            return {
+                content: [{ type: "text", text: successMsg }],
+                details: {
+                    ok: true,
+                    scheduled: true,
+                    focus,
+                    keepRecentTokens: effectiveKeepTokens,
+                    hasCustomSummary: !!pending.summary,
+                },
+            };
+        },
+    });
+}