@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.10

package/dist/cli/agent-server-tcp.js

@@ -23,6 +23,7 @@ import { ChatSessionManager } from "../protocol/chat-session-manager.js";
 import { AgentServer } from "../protocol/server.js";
 import { listenTcp } from "../protocol/tcp-transport.js";
 import { SettingsManager } from "../settings/manager.js";
+import { computeEffectiveDisabledLists } from "../capability-control/disabled-lists.js";
 import { personalizationFrom } from "../settings/personalization.js";
 import { MCPManager } from "../tool-system/mcp-manager.js";
 import { mergePluginMcpServers } from "../plugins/installer/loadPluginMcp.js";
@@ -31,18 +32,24 @@ import { HeadlessApprovalBackend } from "../tool-system/permission.js";
 import { createRunManager } from "../run/factory.js";
 import { startAutomation } from "../automation/index.js";
 import { CronStore, defaultCronStorePath } from "../automation/store.js";
+import { resolveLLMConfigForTag } from "../engine/resolve-llm-config.js";
 const cwd = process.env.AGENT_CWD ?? process.cwd();
 const port = Number(process.env.AGENT_TCP_PORT ?? "4321");
 const host = process.env.AGENT_TCP_HOST ?? "127.0.0.1";
 const settingsManager = new SettingsManager(cwd, "full");
+// Read once at startup and reuse for every session (see engineFactory below).
+// This is intentional for the TCP host: it's a headless long-running server,
+// so config changes — including `mcpServers` — take effect on restart, not
+// mid-session. (The stdio host re-reads per session via freshSettings(); the
+// difference is by design, not a bug. Assessment §4.8.)
 const settings = settingsManager.get();
-const llmConfig = {
-    provider: settings.model.provider,
-    model: settings.model.name,
-    apiKey: settings.model.apiKey ?? "",
-    baseUrl: settings.model.baseUrl,
-    maxTokens: settings.model.maxTokens,
-};
+const seedLlm = resolveLLMConfigForTag(settings, "text", settings.defaults?.text);
+if (!seedLlm) {
+    console.error(`[agent-server] 没有可用的文本模型连接(defaults.text=${settings.defaults?.text ?? "未设置"})。` +
+        `请在「连接」页添加并填写凭证。`);
+    process.exit(1);
+}
+const llmConfig = seedLlm;
 // ── Shared runtime (same bootstrap as stdio) ─────────────────────
 const seedEngine = new Engine({ llm: llmConfig, cwd, settingsScope: "full" });
 const modelPool = seedEngine.getModelPool();
@@ -60,25 +67,32 @@ const runtime = new EngineRuntime({
 });
 const chatManager = new ChatSessionManager({
     runtime,
-    engineFactory: (slice) => new Engine({
-        llm: runtime.modelPool.resolveLLMConfig() ?? resolvedLlmConfig,
-        clientDefaults: resolvedClientDefaults,
-        cwd,
-        runtime,
-        settingsScope: "full",
-        mcpServers: mergePluginMcpServers(settings.mcpServers ?? {}, settings.disabledPlugins ?? []),
-        permissionMode: slice.permissionMode,
-        preset: slice.preset,
-        customSystemPrompt: slice.customSystemPrompt,
-        appendSystemPrompt: slice.appendSystemPrompt,
-        // Personalization + instruction compat come from disk settings only
-        // (not per-request slice overrides) — same disk-only contract as the
-        // stdio host. Shared helper keeps the three fields wired identically.
-        ...personalizationFrom(settings.agent),
-        maxTurns: slice.maxTurns,
-        maxContextTokens: slice.maxContextTokens,
-        ...(slice.cwd ? { cwd: slice.cwd } : {}),
-    }),
+    engineFactory: (slice) => {
+        // Fold project capabilityOverrides over the global disabledPlugins for
+        // the MCP merge (能力总览 project "on" must override global off) — same
+        // contract as the stdio host's factory.
+        const sessionCwd = slice.cwd ?? cwd;
+        const { disabledPlugins } = computeEffectiveDisabledLists(new SettingsManager(sessionCwd, "full"), sessionCwd);
+        return new Engine({
+            llm: runtime.modelPool.resolveLLMConfig() ?? resolvedLlmConfig,
+            clientDefaults: resolvedClientDefaults,
+            cwd,
+            runtime,
+            settingsScope: "full",
+            mcpServers: mergePluginMcpServers(settings.mcpServers ?? {}, disabledPlugins, settings.mcpServerOverrides ?? {}),
+            permissionMode: slice.permissionMode,
+            preset: slice.preset,
+            customSystemPrompt: slice.customSystemPrompt,
+            appendSystemPrompt: slice.appendSystemPrompt,
+            // Personalization + instruction compat come from disk settings only
+            // (not per-request slice overrides) — same disk-only contract as the
+            // stdio host. Shared helper keeps the three fields wired identically.
+            ...personalizationFrom(settings.agent),
+            maxTurns: slice.maxTurns,
+            maxContextTokens: slice.maxContextTokens,
+            ...(slice.cwd ? { cwd: slice.cwd } : {}),
+        });
+    },
     maxSessions: 16,
     idleTtlMs: 30 * 60 * 1000,
 });

package/dist/context/compaction.d.ts

@@ -16,6 +16,54 @@ import type { Message } from "../types.js";
  * Uses per-block-type estimation with 33% overhead padding.
  */
 export declare function estimateTokens(messages: Message[]): number;
+export declare const IMAGE_HISTORY_PLACEHOLDER_PREFIX = "[image #";
+export declare const IMAGE_HISTORY_PLACEHOLDER_SUFFIX = ", \u5DF2\u5904\u7406 / already provided earlier]";
+interface ImagePreserveSet {
+    has(message: Message): boolean;
+}
+export interface DowngradeImageHistoryOptions {
+    /**
+     * Messages whose image payloads are being sent for their first model
+     * consumption in this request. They still count toward image numbering but
+     * keep their base64 until the caller clears the preserve set after a
+     * successful model response.
+     */
+    preserveMessages?: ImagePreserveSet;
+}
+export interface DowngradeImageHistoryResult {
+    messages: Message[];
+    replacedCount: number;
+}
+/**
+ * Replace already-consumed image payload blocks with compact text markers.
+ *
+ * The transcript may retain the full image bytes for rendering/resume, but the
+ * working message history sent to the model should not re-send base64 after the
+ * model has seen it once. This handles both our internal Anthropic-style image
+ * blocks and OpenAI-style data-url image blocks defensively, including images
+ * nested inside tool_result.content arrays (view_image / browser screenshots).
+ */
+export declare function downgradeImagePayloadsInHistory(messages: Message[], options?: DowngradeImageHistoryOptions): DowngradeImageHistoryResult;
+export declare function messageHasBase64ImagePayload(message: Message): boolean;
+/**
+ * Reconcile user-supplied compaction ratios into a safe ordering.
+ *
+ * The three tiers must satisfy `floor < compact < summarize` or the manager
+ * fires them in the wrong order (e.g. an emergency window-compact before the
+ * cheaper summary). Users edit these freely in settings.json, so we clamp
+ * rather than trust: summarize is pulled up to at least compact, floor is
+ * pushed down to at most compact. Absent fields are left undefined so the
+ * ContextManager keeps its own default for them.
+ */
+export declare function clampContextRatios(input: {
+    compactAtRatio?: number;
+    summarizeAtRatio?: number;
+    microcompactFloorRatio?: number;
+}): {
+    compactAtRatio?: number;
+    summarizeAtRatio?: number;
+    microcompactFloorRatio?: number;
+};
 /**
  * Expand a slice start-index backwards so that every tool_result in the
  * kept range has its corresponding tool_use in the kept range too.
@@ -74,6 +122,43 @@ export interface MicrocompactOptions {
  *    forced into blind re-Reads (which then trip the Investigation guard).
  */
 export declare function microcompact(messages: Message[], options?: MicrocompactOptions): Message[];
+export interface DedupeFileReadsResult {
+    messages: Message[];
+    /** How many stale Read results were cleared. */
+    clearedCount: number;
+}
+/**
+ * Content-aware dedup: when the SAME file is Read more than once, every Read
+ * result except the most recent is stale — the file's current state is in the
+ * latest read. Clear the older ones (replace with a fingerprint pointing at
+ * the newer read) regardless of the recency window or pressure floor, because
+ * this is pure waste removal, not lossy compaction: the model never needs two
+ * copies of the same file.
+ *
+ * Distinct from microcompact (which is recency-gated and pressure-gated): a
+ * file Read 3 times in the last 3 turns keeps 3 full copies under microcompact
+ * but only the newest under this pass. Zero-cost and always safe to run, so the
+ * ContextManager calls it as an early tier.
+ *
+ * Only `Read` is deduped (its result is exactly the file content). Edit/Write
+ * results are diffs/confirmations, not full snapshots, so they're left alone.
+ */
+export declare function dedupeFileReads(messages: Message[]): DedupeFileReadsResult;
+/**
+ * Observation masking for browser_observe(snapshot) results (the research's
+ * highest-leverage browser-token saving: a page snapshot is large and only the
+ * LATEST one matters for the next decision; older ones are stale element lists).
+ * Keep the most recent snapshot result verbatim; replace every earlier one with
+ * a one-line placeholder. Deterministic — no LLM summarization needed.
+ *
+ * Keyed on the snapshot OBSERVATION (browser_observe with mode snapshot) — read/
+ * extract observations and act results are left untouched. Renamed from
+ * maskOldBrowserSnapshots when the 9 browser_* tools collapsed into 3.
+ */
+export declare function maskOldObservations(messages: Message[]): {
+    messages: Message[];
+    maskedCount: number;
+};
 /**
  * Apply aggregate per-message tool result budget.
  * When total tool_result content in a single message exceeds maxTotalChars,
@@ -114,3 +199,4 @@ export declare function dropOldestRounds(messages: Message[], roundsToDrop: numb
  * messages. Returns paths only — the model uses Read tool on demand.
  */
 export declare function extractReferencedFilePaths(messages: Message[]): string[];
+export {};

package/dist/context/compaction.js

@@ -18,6 +18,123 @@ import { estimateMessagesTokens } from "./token-counter.js";
 export function estimateTokens(messages) {
     return Math.ceil(estimateMessagesTokens(messages) * (4 / 3));
 }
+export const IMAGE_HISTORY_PLACEHOLDER_PREFIX = "[image #";
+export const IMAGE_HISTORY_PLACEHOLDER_SUFFIX = ", 已处理 / already provided earlier]";
+/**
+ * Replace already-consumed image payload blocks with compact text markers.
+ *
+ * The transcript may retain the full image bytes for rendering/resume, but the
+ * working message history sent to the model should not re-send base64 after the
+ * model has seen it once. This handles both our internal Anthropic-style image
+ * blocks and OpenAI-style data-url image blocks defensively, including images
+ * nested inside tool_result.content arrays (view_image / browser screenshots).
+ */
+export function downgradeImagePayloadsInHistory(messages, options = {}) {
+    let nextImageNumber = 1;
+    let replacedCount = 0;
+    let changed = false;
+    const placeholderFor = (imageNumber) => ({
+        type: "text",
+        text: `${IMAGE_HISTORY_PLACEHOLDER_PREFIX}${imageNumber}${IMAGE_HISTORY_PLACEHOLDER_SUFFIX}`,
+    });
+    const transformBlocks = (blocks, preserve) => {
+        let blocksChanged = false;
+        const out = blocks.map((block) => {
+            const placeholderNumber = imageHistoryPlaceholderNumber(block);
+            if (placeholderNumber !== undefined) {
+                nextImageNumber = Math.max(nextImageNumber, placeholderNumber + 1);
+                return block;
+            }
+            if (isBase64ImageBlock(block)) {
+                const imageNumber = nextImageNumber++;
+                if (preserve)
+                    return block;
+                replacedCount++;
+                blocksChanged = true;
+                return placeholderFor(imageNumber);
+            }
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                const nested = transformBlocks(block.content, preserve);
+                if (nested.changed) {
+                    blocksChanged = true;
+                    return { ...block, content: nested.blocks };
+                }
+            }
+            return block;
+        });
+        return { blocks: blocksChanged ? out : blocks, changed: blocksChanged };
+    };
+    const out = messages.map((msg) => {
+        if (!Array.isArray(msg.content))
+            return msg;
+        const preserve = options.preserveMessages?.has(msg) === true;
+        const result = transformBlocks(msg.content, preserve);
+        if (!result.changed)
+            return msg;
+        changed = true;
+        return { ...msg, content: result.blocks };
+    });
+    return { messages: changed ? out : messages, replacedCount };
+}
+export function messageHasBase64ImagePayload(message) {
+    if (!Array.isArray(message.content))
+        return false;
+    return message.content.some(blockHasBase64ImagePayload);
+}
+function blockHasBase64ImagePayload(block) {
+    if (isBase64ImageBlock(block))
+        return true;
+    return (block.type === "tool_result" &&
+        Array.isArray(block.content) &&
+        block.content.some(blockHasBase64ImagePayload));
+}
+function imageHistoryPlaceholderNumber(block) {
+    if (block.type !== "text" || typeof block.text !== "string")
+        return undefined;
+    const escapedPrefix = IMAGE_HISTORY_PLACEHOLDER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const escapedSuffix = IMAGE_HISTORY_PLACEHOLDER_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = block.text.match(new RegExp(`^${escapedPrefix}(\\d+)${escapedSuffix}$`));
+    if (!match?.[1])
+        return undefined;
+    const n = Number(match[1]);
+    return Number.isSafeInteger(n) && n > 0 ? n : undefined;
+}
+function isBase64ImageBlock(block) {
+    if (block.type === "image" &&
+        block.source?.type === "base64" &&
+        typeof block.source.data === "string" &&
+        block.source.data.length > 0) {
+        return true;
+    }
+    const maybeOpenAI = block;
+    return (maybeOpenAI.type === "image_url" &&
+        typeof maybeOpenAI.image_url?.url === "string" &&
+        /^data:image\/[^;,]+;base64,/i.test(maybeOpenAI.image_url.url));
+}
+/**
+ * Reconcile user-supplied compaction ratios into a safe ordering.
+ *
+ * The three tiers must satisfy `floor < compact < summarize` or the manager
+ * fires them in the wrong order (e.g. an emergency window-compact before the
+ * cheaper summary). Users edit these freely in settings.json, so we clamp
+ * rather than trust: summarize is pulled up to at least compact, floor is
+ * pushed down to at most compact. Absent fields are left undefined so the
+ * ContextManager keeps its own default for them.
+ */
+export function clampContextRatios(input) {
+    const compact = input.compactAtRatio;
+    const summarize = input.summarizeAtRatio !== undefined && compact !== undefined
+        ? Math.max(input.summarizeAtRatio, compact)
+        : input.summarizeAtRatio;
+    const floor = input.microcompactFloorRatio !== undefined && compact !== undefined
+        ? Math.min(input.microcompactFloorRatio, compact)
+        : input.microcompactFloorRatio;
+    return {
+        compactAtRatio: compact,
+        summarizeAtRatio: summarize,
+        microcompactFloorRatio: floor,
+    };
+}
 // ─── Tool Use / Result Pair Protection ──────────────────────────────
 /**
  * Expand a slice start-index backwards so that every tool_result in the
@@ -275,6 +392,168 @@ export function microcompact(messages, options = {}) {
     }
     return result;
 }
+/** Tools whose result is the content of a single file, keyed by path. */
+const FILE_READ_TOOLS = new Set(["Read"]);
+/**
+ * Content-aware dedup: when the SAME file is Read more than once, every Read
+ * result except the most recent is stale — the file's current state is in the
+ * latest read. Clear the older ones (replace with a fingerprint pointing at
+ * the newer read) regardless of the recency window or pressure floor, because
+ * this is pure waste removal, not lossy compaction: the model never needs two
+ * copies of the same file.
+ *
+ * Distinct from microcompact (which is recency-gated and pressure-gated): a
+ * file Read 3 times in the last 3 turns keeps 3 full copies under microcompact
+ * but only the newest under this pass. Zero-cost and always safe to run, so the
+ * ContextManager calls it as an early tier.
+ *
+ * Only `Read` is deduped (its result is exactly the file content). Edit/Write
+ * results are diffs/confirmations, not full snapshots, so they're left alone.
+ */
+export function dedupeFileReads(messages) {
+    const idToName = buildToolUseIdToNameMap(messages);
+    const idToInput = new Map();
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type === "tool_use" && block.id)
+                idToInput.set(block.id, block.input);
+        }
+    }
+    // Resolve a Read tool_use_id to its file_path arg (the dedup key).
+    const pathOf = (toolUseId) => {
+        const input = idToInput.get(toolUseId);
+        const p = input?.file_path ?? input?.path;
+        return typeof p === "string" && p.length > 0 ? p : undefined;
+    };
+    // Collect, per file path, the message indices + block positions of every
+    // non-cleared Read result. Walk forward so "last" is the newest.
+    const byPath = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type !== "tool_result" || !block.tool_use_id)
+                continue;
+            if (!FILE_READ_TOOLS.has(idToName.get(block.tool_use_id) ?? ""))
+                continue;
+            if (typeof block.content !== "string")
+                continue;
+            if (block.content.startsWith("[Old tool result cleared"))
+                continue;
+            const path = pathOf(block.tool_use_id);
+            if (!path)
+                continue;
+            const list = byPath.get(path) ?? [];
+            list.push({ msgIdx: i, toolUseId: block.tool_use_id });
+            byPath.set(path, list);
+        }
+    }
+    // For each path read more than once, mark all-but-last for clearing.
+    const clearIds = new Set();
+    for (const [, reads] of byPath) {
+        if (reads.length < 2)
+            continue;
+        for (let k = 0; k < reads.length - 1; k++)
+            clearIds.add(reads[k].toolUseId);
+    }
+    if (clearIds.size === 0)
+        return { messages, clearedCount: 0 };
+    let clearedCount = 0;
+    const result = messages.map((msg) => {
+        if (!Array.isArray(msg.content))
+            return msg;
+        return {
+            ...msg,
+            content: msg.content.map((block) => {
+                if (block.type !== "tool_result" || !block.tool_use_id)
+                    return block;
+                if (!clearIds.has(block.tool_use_id))
+                    return block;
+                const argsSummary = summarizeToolCallArgs("Read", idToInput.get(block.tool_use_id));
+                clearedCount++;
+                return {
+                    ...block,
+                    content: `[Old tool result cleared — superseded by a newer Read${argsSummary ? ` of ${argsSummary}` : ""}]`,
+                };
+            }),
+        };
+    });
+    return { messages: result, clearedCount };
+}
+/** Build id → true for tool_use blocks that are a browser snapshot observation,
+ *  i.e. `browser_observe` with mode "snapshot" (the default when mode omitted).
+ *  Only snapshots produce large, supersede-able element lists worth masking. */
+function buildSnapshotObserveIdSet(messages) {
+    const ids = new Set();
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type !== "tool_use" || !block.id || block.name !== "browser_observe")
+                continue;
+            const mode = block.input?.mode;
+            if (mode === undefined || mode === "snapshot")
+                ids.add(block.id);
+        }
+    }
+    return ids;
+}
+const OLD_SNAPSHOT_PLACEHOLDER = "[Old browser snapshot collapsed — superseded by a newer browser_observe(snapshot). " +
+    "Re-run browser_observe for the current page's elements.]";
+/**
+ * Observation masking for browser_observe(snapshot) results (the research's
+ * highest-leverage browser-token saving: a page snapshot is large and only the
+ * LATEST one matters for the next decision; older ones are stale element lists).
+ * Keep the most recent snapshot result verbatim; replace every earlier one with
+ * a one-line placeholder. Deterministic — no LLM summarization needed.
+ *
+ * Keyed on the snapshot OBSERVATION (browser_observe with mode snapshot) — read/
+ * extract observations and act results are left untouched. Renamed from
+ * maskOldBrowserSnapshots when the 9 browser_* tools collapsed into 3.
+ */
+export function maskOldObservations(messages) {
+    const snapshotIds = buildSnapshotObserveIdSet(messages);
+    const snapResults = [];
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type !== "tool_result" || !block.tool_use_id)
+                continue;
+            if (!snapshotIds.has(block.tool_use_id))
+                continue;
+            if (typeof block.content !== "string")
+                continue;
+            if (block.content.startsWith("[Old browser snapshot collapsed"))
+                continue;
+            snapResults.push(block.tool_use_id);
+        }
+    }
+    if (snapResults.length < 2)
+        return { messages, maskedCount: 0 };
+    // Mask all but the last (newest walked-forward).
+    const maskIds = new Set(snapResults.slice(0, -1));
+    let maskedCount = 0;
+    const result = messages.map((msg) => {
+        if (!Array.isArray(msg.content))
+            return msg;
+        return {
+            ...msg,
+            content: msg.content.map((block) => {
+                if (block.type !== "tool_result" || !block.tool_use_id)
+                    return block;
+                if (!maskIds.has(block.tool_use_id))
+                    return block;
+                maskedCount++;
+                return { ...block, content: OLD_SNAPSHOT_PLACEHOLDER };
+            }),
+        };
+    });
+    return { messages: result, maskedCount };
+}
 /**
  * Apply aggregate per-message tool result budget.
  * When total tool_result content in a single message exceeds maxTotalChars,

package/dist/context/manager.d.ts

@@ -41,6 +41,8 @@ export declare class ContextManager {
     private config;
     private summarizeFn;
     private consecutiveSummaryFailures;
+    /** Prevents repeated spin-band LLM calls after a summary generated no shrink. */
+    private suppressNoOpMicroSummaryUntilCompact;
     private lastSummary;
     /** Last known actual token count from API usage data. */
     private lastActualTokens;
@@ -73,6 +75,7 @@ export declare class ContextManager {
      * Set the summarize function (injected by Engine).
      */
     setSummarizeFn(fn: SummarizeFn): void;
+    private trySummaryCompact;
     /**
      * Set the transcript path so compaction can reference it. The
      * tool-results directory lives alongside the transcript file:
@@ -97,6 +100,21 @@ export declare class ContextManager {
      * Call this when you have access to the LLM (between turns).
      */
     manageAsync(messages: Message[]): Promise<Message[]>;
+    /**
+     * Force maximum compaction, ignoring the ratio gates. This is what a manual
+     * `/compact` invokes: the user explicitly asked to shrink NOW, so we don't
+     * wait for the prompt to reach compactAtRatio.
+     *
+     * Order: tier-0 cleanups (persist/truncate/dedupe/mask) + microcompact, then
+     * an unconditional LLM summary of the older messages. If no summarizeFn is
+     * wired (or it fails / yields nothing), fall back to snip → window so the
+     * call still shrinks the conversation rather than no-opping.
+     *
+     * Unlike manage()/manageAsync(), there is NO `ratio >= compactAtRatio` gate:
+     * a long-but-under-threshold text-only conversation (the /compact bug) still
+     * gets summarized here.
+     */
+    forceSummarize(messages: Message[]): Promise<Message[]>;
     /**
      * Persist large tool_result blocks to disk and replace them with a
      * preview + filepath. No-op when transcript path hasn't been set