pigpig-agent 1.0.0

package/dist/commands/dream.js

@@ -0,0 +1,36 @@
+import { agentLoop } from '../agent/loop.js';
+const DREAM_PROMPT = [
+    '请对记忆库做一次完整的整理（dream），按以下四个阶段执行：',
+    '',
+    '**阶段 1：定位** — 用 memory lint 扫描全库（lint 结果已包含内容预览和问题清单，不需要再逐条 read）。',
+    '**阶段 2：整理** — 根据 lint 报告直接操作：',
+    '  - 路径过期且长期未用的，直接 memory delete（传 filename）删掉',
+    '  - 同名重复的，用 memory save 保存合并后的版本（同名自动覆盖），再 delete 多余的',
+    '  - 内容仍然有效但描述不准确的，用 memory save 覆盖更新',
+    '**阶段 3：报告** — 用一段文字总结这次整理做了什么。',
+    '',
+    '注意：memory 的 read 和 delete 都需要传 filename 参数（如 project_deploy-process.md），不是 name。lint 报告里已经有 filename 了，直接用。',
+].join('\n');
+export const dreamCommands = [
+    (cmd, ctx) => {
+        if (cmd !== '/dream' && cmd !== 'dream')
+            return false;
+        console.log('\n[dream] 开始记忆整理...');
+        const userMsg = { role: 'user', content: DREAM_PROMPT };
+        ctx.messages.push(userMsg);
+        ctx.timestamps.set(ctx.messages.length - 1, Date.now());
+        ctx.sessionStore.append(userMsg);
+        const currentSystem = ctx.builder.build(ctx.makePromptCtx());
+        const beforeLen = ctx.messages.length;
+        agentLoop(ctx.model, ctx.registry, ctx.messages, currentSystem, ctx.tracker).then(() => {
+            const newMessages = ctx.messages.slice(beforeLen);
+            const now = Date.now();
+            for (let i = beforeLen; i < ctx.messages.length; i++)
+                ctx.timestamps.set(i, now);
+            ctx.sessionStore.appendAll(newMessages);
+            console.log(`  [dream 完成]\n`);
+            ctx.ask();
+        });
+        return 'async';
+    },
+];

package/dist/commands/index.js

@@ -0,0 +1,10 @@
+export function createDispatcher(handlers) {
+    return (cmd, ctx) => {
+        for (const h of handlers) {
+            const result = h(cmd, ctx);
+            if (result)
+                return result;
+        }
+        return false;
+    };
+}

package/dist/commands/memory.js

@@ -0,0 +1,40 @@
+export const memoryCommands = [
+    (cmd, ctx) => {
+        if (cmd !== '/memory' && cmd !== 'memory')
+            return false;
+        const entries = ctx.memoryStore.list();
+        console.log(`\n[记忆系统] 共 ${entries.length} 条记忆`);
+        for (const e of entries)
+            console.log(`  [${e.type}] ${e.name} — ${e.description}`);
+        console.log('');
+        return true;
+    },
+    (cmd, ctx) => {
+        if (!cmd.startsWith('/memory search '))
+            return false;
+        const query = cmd.slice('/memory search '.length).trim();
+        const results = ctx.memoryStore.search(query);
+        console.log(`\n[记忆搜索] "${query}" → ${results.length} 条结果`);
+        for (const e of results)
+            console.log(`  [${e.type}] ${e.name} — ${e.description}`);
+        console.log('');
+        return true;
+    },
+    (cmd, ctx) => {
+        if (cmd !== '/lint' && cmd !== 'lint')
+            return false;
+        const reports = ctx.memoryStore.lint();
+        if (reports.length === 0) {
+            console.log('\n[lint] 记忆库健康，没有发现问题。\n');
+            return true;
+        }
+        console.log(`\n[lint] 记忆库 ${reports.length} 条有警告：`);
+        for (const r of reports) {
+            console.log(`  📁 ${r.entry.filePath.split('/').pop()}  [${r.entry.type}] ${r.entry.name}`);
+            for (const issue of r.issues)
+                console.log(`     • ${issue.kind}: ${issue.message}`);
+        }
+        console.log('');
+        return true;
+    },
+];

package/dist/commands/plugin.js

@@ -0,0 +1,73 @@
+export function createPluginCommands(pluginManager, availablePlugins) {
+    return [
+        // /plugin 或 /plugin list
+        (cmd, _ctx) => {
+            if (cmd !== '/plugin' && cmd !== '/plugin list')
+                return false;
+            const loaded = pluginManager.list();
+            const unloaded = Array.from(availablePlugins.entries())
+                .filter(([name]) => !loaded.find(p => p.name === name));
+            if (loaded.length === 0 && unloaded.length === 0) {
+                console.log('\n[plugins] 没有可用的插件。\n');
+                return true;
+            }
+            console.log('\n[plugins]');
+            if (loaded.length > 0) {
+                console.log('  已加载：');
+                for (const p of loaded) {
+                    console.log(`    ${p.name} v${p.version} — ${p.description}`);
+                    console.log(`      工具: ${p.tools.join(', ')}`);
+                }
+            }
+            if (unloaded.length > 0) {
+                console.log('  可加载：');
+                for (const [name, def] of unloaded) {
+                    console.log(`    ${name} v${def.version} — ${def.description}`);
+                }
+            }
+            console.log('');
+            return true;
+        },
+        // /plugin load <name>
+        (cmd, _ctx) => {
+            const match = cmd.match(/^\/plugin\s+load\s+(\S+)$/);
+            if (!match)
+                return false;
+            const name = match[1];
+            const def = availablePlugins.get(name);
+            if (!def) {
+                console.log(`\n[plugins] 找不到插件: ${name}\n`);
+                return true;
+            }
+            if (pluginManager.get(name)) {
+                console.log(`\n[plugins] ${name} 已经加载了\n`);
+                return true;
+            }
+            pluginManager.load(def).then(tools => {
+                console.log(`\n[plugins] 已加载 ${name}，注册了 ${tools.length} 个工具：`);
+                for (const t of tools)
+                    console.log(`    ${t}`);
+                console.log('');
+            }).catch(err => {
+                console.log(`\n[plugins] 加载 ${name} 失败: ${err.message}\n`);
+            });
+            return true;
+        },
+        // /plugin unload <name>
+        (cmd, _ctx) => {
+            const match = cmd.match(/^\/plugin\s+unload\s+(\S+)$/);
+            if (!match)
+                return false;
+            const name = match[1];
+            pluginManager.unload(name).then(ok => {
+                if (ok) {
+                    console.log(`\n[plugins] 已卸载 ${name}，相关工具已移除\n`);
+                }
+                else {
+                    console.log(`\n[plugins] ${name} 未加载\n`);
+                }
+            });
+            return true;
+        },
+    ];
+}

package/dist/commands/rag.js

@@ -0,0 +1,25 @@
+export const ragCommands = [
+    (cmd, ctx) => {
+        if (cmd !== '/rag' && cmd !== 'rag')
+            return false;
+        const vs = ctx.vectorStore;
+        console.log(`\n[知识库] ${vs.size()} 个片段`);
+        const sources = vs.sources();
+        if (sources.length > 0)
+            console.log(`  来源: ${sources.join(', ')}`);
+        console.log('');
+        return true;
+    },
+    (cmd, ctx) => {
+        if (!cmd.startsWith('ingest '))
+            return false;
+        const path = cmd.slice('ingest '.length).trim();
+        console.log(`\n[导入] 正在处理 ${path}...`);
+        const ragIngestTool = ctx.registry.getActiveTools().find(t => t.name === 'rag_ingest');
+        ragIngestTool.execute({ path }).then((result) => {
+            console.log(`  ${result}\n`);
+            ctx.ask();
+        });
+        return 'async';
+    },
+];

package/dist/commands/security.js

@@ -0,0 +1,44 @@
+export function createSecurityCommands(registry, hookPipeline) {
+    return [
+        // /role [owner|collaborator|guest]
+        (cmd, _ctx) => {
+            const match = cmd.match(/^\/role(?:\s+(owner|collaborator|guest))?$/);
+            if (!match)
+                return false;
+            if (match[1]) {
+                const role = match[1];
+                registry.setRole(role);
+                const toolCount = registry.getActiveTools().length;
+                console.log(`\n[security] 角色切换为 ${role}，可用工具: ${toolCount} 个\n`);
+            }
+            else {
+                const role = registry.getRole();
+                const toolCount = registry.getActiveTools().length;
+                console.log(`\n[security] 当前角色: ${role}，可用工具: ${toolCount} 个\n`);
+            }
+            return true;
+        },
+        // /hooks
+        (cmd, _ctx) => {
+            if (cmd !== '/hooks')
+                return false;
+            const hooks = hookPipeline.list();
+            console.log('\n[hooks]');
+            if (hooks.pre.length > 0) {
+                console.log('  Pre-Tool Hooks:');
+                for (const name of hooks.pre)
+                    console.log(`    - ${name}`);
+            }
+            if (hooks.post.length > 0) {
+                console.log('  Post-Tool Hooks:');
+                for (const name of hooks.post)
+                    console.log(`    - ${name}`);
+            }
+            if (hooks.pre.length === 0 && hooks.post.length === 0) {
+                console.log('  没有注册的 Hook');
+            }
+            console.log('');
+            return true;
+        },
+    ];
+}

package/dist/commands/skill.js

@@ -0,0 +1,84 @@
+import { agentLoop } from '../agent/loop.js';
+export function createSkillCommands(skillLoader, activeSkills) {
+    return [
+        // /skill list
+        (cmd, ctx) => {
+            if (cmd !== '/skill' && cmd !== '/skill list' && cmd !== 'skill list')
+                return false;
+            const skills = skillLoader.list();
+            if (skills.length === 0) {
+                console.log('\n[skills] 没有找到任何 skill。在 .skills/ 目录下创建 skill-name/SKILL.md 即可。\n');
+                return true;
+            }
+            console.log(`\n[skills] 共 ${skills.length} 个可用：`);
+            for (const s of skills) {
+                const active = activeSkills.has(s.name) ? ' ✓ 已激活' : '';
+                console.log(`  /${s.name} — ${s.description}${active}`);
+                if (s.whenToUse)
+                    console.log(`    适用场景: ${s.whenToUse}`);
+            }
+            console.log('');
+            return true;
+        },
+        // /skill load <name>
+        (cmd, ctx) => {
+            const match = cmd.match(/^\/skill\s+load\s+(\S+)$/);
+            if (!match)
+                return false;
+            const name = match[1];
+            const skill = skillLoader.get(name);
+            if (!skill) {
+                console.log(`\n[skills] 找不到 skill: ${name}\n`);
+                return true;
+            }
+            activeSkills.add(name);
+            console.log(`\n[skills] 已激活: ${name} — ${skill.description}\n`);
+            return true;
+        },
+        // /skill unload <name>
+        (cmd, ctx) => {
+            const match = cmd.match(/^\/skill\s+unload\s+(\S+)$/);
+            if (!match)
+                return false;
+            const name = match[1];
+            if (!activeSkills.has(name)) {
+                console.log(`\n[skills] ${name} 未激活\n`);
+                return true;
+            }
+            activeSkills.delete(name);
+            console.log(`\n[skills] 已卸载: ${name}\n`);
+            return true;
+        },
+        // /<skill-name> — 直接用 /code-review 激活并触发
+        (cmd, ctx) => {
+            if (!cmd.startsWith('/'))
+                return false;
+            const parts = cmd.slice(1).split(/\s+/);
+            const name = parts[0];
+            const skill = skillLoader.get(name);
+            if (!skill)
+                return false;
+            activeSkills.add(name);
+            console.log(`\n[skills] 激活 ${name}，开始执行...`);
+            const args = parts.slice(1).join(' ');
+            const content = args
+                ? `${skill.content}\n\n用户指令: ${args}`
+                : skill.content;
+            const userMsg = { role: 'user', content };
+            ctx.messages.push(userMsg);
+            ctx.timestamps.set(ctx.messages.length - 1, Date.now());
+            ctx.sessionStore.append(userMsg);
+            const currentSystem = ctx.builder.build(ctx.makePromptCtx());
+            const beforeLen = ctx.messages.length;
+            agentLoop(ctx.model, ctx.registry, ctx.messages, currentSystem, ctx.tracker).then(() => {
+                const newMessages = ctx.messages.slice(beforeLen);
+                const now = Date.now();
+                for (let i = beforeLen; i < ctx.messages.length; i++)
+                    ctx.timestamps.set(i, now);
+                ctx.sessionStore.appendAll(newMessages);
+                ctx.ask();
+            });
+            return 'async';
+        },
+    ];
+}

package/dist/config/init.js

@@ -0,0 +1,69 @@
+import { createInterface } from 'node:readline';
+import fs from 'node:fs';
+import { CONFIG_FILE } from './loader.js';
+export async function runInit() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => {
+        console.log(q);
+        rl.question('  > ', resolve);
+    });
+    console.log('\n  Pigpig Agent 初始化向导\n');
+    if (fs.existsSync(CONFIG_FILE)) {
+        const overwrite = await ask(`  ${CONFIG_FILE} 已存在，覆盖? (y/N): `);
+        if (overwrite.toLowerCase() !== 'y') {
+            console.log('  已取消\n');
+            rl.close();
+            return;
+        }
+    }
+    console.log('  选择模型:\n');
+    console.log('    1. glm-5   (推荐，均衡)');
+    console.log('    2. qwen-turbo-latest   (快速，便宜)');
+    console.log('    3. qwen-max-latest    (最强，贵)\n');
+    const modelChoice = (await ask('  模型 [1]: ')) || '1';
+    const models = {
+        '1': 'glm-5',
+        '2': 'qwen-turbo-latest',
+        '3': 'qwen-max-latest',
+    };
+    const modelName = models[modelChoice] || 'glm-5';
+    const apiKey = await ask('\n  DashScope API Key (留空则从环境变量 DASHSCOPE_API_KEY 读取): ');
+    // const enableFeishu = (await ask('\n  启用飞书 Channel? (y/N): ')).toLowerCase() === 'y';
+    // let feishuAppId = '';
+    // let feishuAppSecret = '';
+    // if (enableFeishu) {
+    //     feishuAppId = await ask('  飞书 App ID: ');
+    //     feishuAppSecret = await ask('  飞书 App Secret: ');
+    // }
+    const concurrentStr = await ask('\n  子 Agent 最大并发数 [3]: ');
+    const maxConcurrent = parseInt(concurrentStr) || 3;
+    const config = {
+        version: '1.0',
+        model: {
+            provider: 'dashscope',
+            name: modelName,
+            baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+            apiKey: apiKey || '${DASHSCOPE_API_KEY}',
+        },
+        plugins: [{ name: 'supabase', enabled: false, config: {} }],
+        channels: {},
+        agents: { maxSpawnDepth: 1, maxConcurrent, defaultTimeout: 600000 },
+        security: { defaultRole: 'developer', auditLog: true, bashTimestamp: true },
+        memory: { dataDir: '.' },
+        rag: { enabled: true, docsDir: 'docs' },
+        cron: { enabled: true, dataDir: '.' },
+        session: { id: 'default' },
+        usage: { trackingFile: '.usage/today.jsonl' },
+    };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+    console.log(`\n  ✓ ${CONFIG_FILE} 已生成`);
+    const envLines = [];
+    if (apiKey)
+        envLines.push(`DASHSCOPE_API_KEY=${apiKey}`);
+    if (envLines.length > 0) {
+        fs.writeFileSync('.env', envLines.join('\n') + '\n');
+        console.log('  ✓ .env 已生成');
+    }
+    console.log('\n  启动 Agent: pigpig-agent\n');
+    rl.close();
+}

package/dist/config/loader.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import { SuperAgentConfigSchema } from './schema.js';
+export const CONFIG_FILE = 'pigpig-agent.config.json';
+const ENV_VAR_RE = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
+function substituteEnvVars(obj) {
+    if (typeof obj === 'string') {
+        return obj.replace(ENV_VAR_RE, (match, name) => {
+            const val = process.env[name];
+            if (val === undefined) {
+                console.warn(`  ⚠ 环境变量 ${name} 未设置，保留原值`);
+                return match;
+            }
+            return val;
+        });
+    }
+    if (Array.isArray(obj))
+        return obj.map(substituteEnvVars);
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = substituteEnvVars(value);
+        }
+        return result;
+    }
+    return obj;
+}
+export function loadConfig(path = CONFIG_FILE) {
+    if (!fs.existsSync(path)) {
+        console.log(`  未找到 ${path}，使用默认配置`);
+        console.log('  运行 pigpig-agent init 生成配置文件\n');
+        return SuperAgentConfigSchema.parse({});
+    }
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(path, 'utf-8'));
+    }
+    catch (err) {
+        console.error(`  ✗ 解析 ${path} 失败: ${err.message}`);
+        process.exit(1);
+    }
+    const substituted = substituteEnvVars(raw);
+    const result = SuperAgentConfigSchema.safeParse(substituted);
+    if (!result.success) {
+        console.error('  ✗ 配置文件校验失败:');
+        for (const issue of result.error.issues) {
+            console.error(`    ${issue.path.join('.')}: ${issue.message}`);
+        }
+        process.exit(1);
+    }
+    console.log(`  ✓ 已加载 ${path}`);
+    return result.data;
+}

package/dist/config/schema.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export const ModelConfigSchema = z.object({
+    provider: z.enum(['dashscope', 'openai', 'custom']).default('dashscope'),
+    name: z.string().default('glm-5'),
+    baseURL: z.string().default('https://dashscope.aliyuncs.com/compatible-mode/v1'),
+    apiKey: z.string().default(''),
+});
+export const PluginConfigSchema = z.object({
+    name: z.string(),
+    enabled: z.boolean().default(true),
+    config: z.record(z.string(), z.any()).default({}),
+});
+export const AgentConfigSchema = z.object({
+    maxSpawnDepth: z.number().min(0).max(5).default(1),
+    maxConcurrent: z.number().min(1).max(10).default(3),
+    defaultTimeout: z.number().default(600000),
+});
+export const SecurityConfigSchema = z.object({
+    defaultRole: z.string().default('developer'),
+    auditLog: z.boolean().default(true),
+    bashTimestamp: z.boolean().default(true),
+});
+export const MemoryConfigSchema = z.object({
+    dataDir: z.string().default('.'),
+});
+export const RagConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    docsDir: z.string().default('docs'),
+});
+export const CronConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    dataDir: z.string().default('.'),
+});
+export const SessionConfigSchema = z.object({
+    id: z.string().default('default'),
+});
+export const UsageConfigSchema = z.object({
+    trackingFile: z.string().default('.usage/today.jsonl'),
+});
+// Zod v4 中 ZodObject.default() 的入参须是完整 output 类型（字段全必填），
+// 即使内部字段都带 default，传 {} 也会类型报错。
+// 这里用各 schema.parse({}) 生成应用全部默认值后的完整对象作为默认值，
+// 语义与 Zod v3 的 .default({}) 一致：配置缺省该段时套用嵌套默认值。
+export const SuperAgentConfigSchema = z.object({
+    version: z.string().default('1.0'),
+    model: ModelConfigSchema.default(ModelConfigSchema.parse({})),
+    plugins: z.array(PluginConfigSchema).default([]),
+    agents: AgentConfigSchema.default(AgentConfigSchema.parse({})),
+    security: SecurityConfigSchema.default(SecurityConfigSchema.parse({})),
+    memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),
+    rag: RagConfigSchema.default(RagConfigSchema.parse({})),
+    cron: CronConfigSchema.default(CronConfigSchema.parse({})),
+    session: SessionConfigSchema.default(SessionConfigSchema.parse({})),
+    usage: UsageConfigSchema.default(UsageConfigSchema.parse({})),
+});

package/dist/context/compressor.js

@@ -0,0 +1,165 @@
+import { generateText } from 'ai';
+import { textToolResultOutput, toolResultOutputToText } from './tool-result-output.js';
+// 计算对话历史的token数量
+export function estimateTokens(messages) {
+    let chars = 0;
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            chars += msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if ('text' in part && typeof part.text === 'string') {
+                    chars += part.text.length;
+                }
+                else if ('output' in part) {
+                    chars += toolResultOutputToText(part.output).length;
+                }
+            }
+        }
+    }
+    return Math.ceil(chars / 4);
+}
+// 允许被压缩的工具
+const CLEARABLE_TOOLS = new Set([
+    'read_file', 'bash', 'glob', 'list_directory', 'edit_file', 'write_file'
+]);
+const KEEP_RECENT_TOOL_RESULT = 3; // 保留最近的3个工具调用结果
+// 1. 紧凑压缩 只将工具调用结果输出压缩为[tool result cleared]格式
+export function microcompact(messages) {
+    // 找到所有的工具调用的索引位置
+    const toolResultIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].role === 'tool') {
+            toolResultIndices.push(i);
+        }
+    }
+    // 保留最近的3个工具调用结果
+    const toClear = toolResultIndices.slice(0, Math.max(0, toolResultIndices.length - KEEP_RECENT_TOOL_RESULT));
+    let cleared = 0;
+    const result = messages.map((msg, idx) => {
+        if (!toClear.includes(idx))
+            return msg;
+        if (msg.role !== 'tool' || !Array.isArray(msg.content))
+            return msg;
+        // 不允许压缩的工具
+        const toolName = msg.content[0].toolName || 'unknown';
+        if (!CLEARABLE_TOOLS.has(toolName))
+            return msg;
+        cleared++;
+        return {
+            ...msg,
+            content: msg.content.map((part) => ({
+                ...part,
+                output: textToolResultOutput(`[tool result cleared ]`),
+            }))
+        };
+    });
+    return {
+        messages: result,
+        cleared,
+    };
+}
+// 2. 摘要压缩 LLM摘要压缩
+const COMPRESS_PROMPT = `你是一个对话压缩系统。你的任务是把 Agent 和用户之间的
+对话历史压缩成一份结构化摘要，确保后续对话能够无缝继续。
+
+请严格按照以下模板输出，每个字段都要填写：
+
+## 用户意图
+（用户在这次对话中想要完成什么）
+
+## 已完成的操作
+（Agent 执行了哪些工具调用、产生了什么结果）
+
+## 关键发现
+（读取的文件内容要点、搜索结果、命令输出中的关键信息）
+
+## 当前状态
+（对话进行到哪一步了、还有什么没做完）
+
+## 需要保留的细节
+（文件路径、变量名、配置值、错误信息等不能丢失的具体内容）
+
+注意事项：
+- 用对话中使用的语言输出
+- 文件路径、UUID、版本号等标识符必须原样保留，不要翻译或改写
+- 不要写笼统的概述，只保留具体的、可操作的信息
+- 总长度控制在 800 字以内`;
+const CONTEXT_TOKEN_THRESHOLD = 300; // 如果当前的对话消息开销<30000token，就不摘要
+const KEEP_RECENT_MESSAGES = 6; // 保留最近的6条消息的原始内容
+export async function summarize(model, messages, existingSummary) {
+    const tokenEstimate = estimateTokens(messages);
+    if (tokenEstimate < CONTEXT_TOKEN_THRESHOLD || messages.length <= KEEP_RECENT_MESSAGES) {
+        return {
+            messages,
+            summary: existingSummary || '',
+            compressedCount: 0,
+        };
+    }
+    const splitIdx = Math.max(0, messages.length - KEEP_RECENT_MESSAGES);
+    let alignedIdx = splitIdx;
+    while (alignedIdx > 0 && messages[alignedIdx].role !== 'user') { // 如果要摘要的数据最后一条不是用户消息，那就往前多退一条
+        alignedIdx--;
+    }
+    if (alignedIdx === 0) {
+        return {
+            messages,
+            summary: existingSummary || '',
+            compressedCount: 0,
+        };
+    }
+    const toCompress = messages.slice(0, alignedIdx); // 要压缩的消息
+    const toKeep = messages.slice(alignedIdx); // 要保留的消息
+    // 将用户消息、Agent消息、工具调用结果拼接为一个字符串
+    const conversationText = toCompress
+        .map(msg => {
+        const content = typeof msg.content === 'string'
+            ? msg.content
+            : Array.isArray(msg.content)
+                ? msg.content.map(part => 'text' in part
+                    ? part.text
+                    : 'output' in part
+                        ? toolResultOutputToText(part.output)
+                        : '').join('')
+                : '';
+        return content ? `**${msg.role}**: ${content}` : '';
+    })
+        .filter(Boolean)
+        .join('\n\n');
+    if (!conversationText.trim()) {
+        return {
+            messages,
+            summary: existingSummary || '',
+            compressedCount: 0,
+        };
+    }
+    const userPrompt = existingSummary
+        ? `## 已有摘要（上一次压缩的结果）\n\n${existingSummary}\n\n## 需要压缩的新对话\n\n${conversationText}`
+        : conversationText;
+    try {
+        const { text: summary } = await generateText({
+            model,
+            system: COMPRESS_PROMPT,
+            prompt: userPrompt,
+        });
+        const summaryMessage = {
+            role: 'user',
+            content: `[以下是之前对话的压缩摘要]\n\n${summary}\n\n[摘要结束，以下是最近的对话]`,
+        };
+        const newMessages = [summaryMessage, ...toKeep];
+        return {
+            messages: newMessages,
+            summary,
+            compressedCount: toCompress.length,
+        };
+    }
+    catch (error) {
+        console.error('[Compaction] LLM摘要失败:', error);
+        return {
+            messages,
+            summary: existingSummary || '',
+            compressedCount: 0,
+        };
+    }
+}