zhitalk 0.1.0 → 0.1.1

package/dist/agent/agent.js

@@ -4,8 +4,8 @@ import { StateGraph, Annotation, START, END, interrupt, Command, GraphRecursionE
 import { messagesStateReducer } from '@langchain/langgraph';
 import { DB_PATH } from './db.js';
 import { tools, maybePersistedOutput, initTools } from './tools.js';
-import { compressMessages } from './context.js';
-import { systemPrompt } from './prompt.js';
+import { compressMessages, findSafeCompressionIndex } from './context.js';
+import { buildSystemPrompt } from './prompt.js';
 import { formatToolLog, formatTodoList } from './colors.js';
 import { processTodoCalls, formatTodoListForPrompt } from './todo.js';
 import { checkReadPermission } from './permission/read.js';
@@ -126,7 +126,7 @@ function createAgentGraph(toolList) {
             }
             return true;
         });
-        const messages = [new SystemMessage(systemPrompt)];
+        const messages = [new SystemMessage(buildSystemPrompt())];
         if (state.todoList && state.todoList.length > 0) {
             messages.push(new SystemMessage(`当前任务进度：\n${formatTodoListForPrompt(state.todoList)}`));
         }
@@ -399,14 +399,15 @@ export async function compressContext(threadId) {
     const lastIndex = currentState.values.lastCompressedIndex || 0;
     const count = currentState.values.compressionCount || 0;
     const recentKeep = 6;
-    if (messages.length <= recentKeep + lastIndex) {
+    const safeIndex = findSafeCompressionIndex(messages, recentKeep);
+    if (safeIndex <= lastIndex) {
         return { didCompress: false, count };
     }
-    const toCompress = messages.slice(lastIndex, messages.length - recentKeep);
+    const toCompress = messages.slice(lastIndex, safeIndex);
     const newSummary = await compressMessages(toCompress, existingSummary);
     await getAgent().updateState(config, {
         contextSummary: newSummary,
-        lastCompressedIndex: messages.length - recentKeep,
+        lastCompressedIndex: safeIndex,
         compressionCount: count + 1,
     });
     return { didCompress: true, count: count + 1 };

package/dist/agent/context.d.ts

@@ -1,3 +1,10 @@
 import { BaseMessage } from '@langchain/core/messages';
 export declare function getModelContextLimit(): number;
 export declare function compressMessages(messages: BaseMessage[], existingSummary: string | null): Promise<string>;
+/**
+ * 计算安全的压缩边界索引，确保保留区域内的 tool_calls 和 ToolMessage 配对完整。
+ *
+ * 策略：从 messages.length - minKeep 开始，如果边界切在了 ToolMessage 或其对应的
+ * AIMessage 之前，就把边界往前移动，直到整个工具调用单元都被保留。
+ */
+export declare function findSafeCompressionIndex(messages: BaseMessage[], minKeep: number): number;

package/dist/agent/context.js

@@ -1,4 +1,4 @@
-import { HumanMessage, } from '@langchain/core/messages';
+import { HumanMessage, AIMessage, } from '@langchain/core/messages';
 import { createModel } from './model.js';
 import { getModelConfig } from './config.js';
 const MODEL_CONTEXT_LIMITS = {
@@ -107,3 +107,45 @@ ${text}`;
     }
     return newSummary;
 }
+/**
+ * 计算安全的压缩边界索引，确保保留区域内的 tool_calls 和 ToolMessage 配对完整。
+ *
+ * 策略：从 messages.length - minKeep 开始，如果边界切在了 ToolMessage 或其对应的
+ * AIMessage 之前，就把边界往前移动，直到整个工具调用单元都被保留。
+ */
+export function findSafeCompressionIndex(messages, minKeep) {
+    let index = Math.max(0, messages.length - minKeep);
+    // 收集当前保留区域内所有 ToolMessage 的 tool_call_id
+    const toolCallIdsInKeepRegion = new Set();
+    for (let i = index; i < messages.length; i++) {
+        if (messages[i].type === 'tool') {
+            toolCallIdsInKeepRegion.add(messages[i].tool_call_id);
+        }
+    }
+    // 往前移动 index，直到所有 toolCallIdsInKeepRegion 都能在保留区域内找到对应的 AIMessage
+    while (index > 0) {
+        const prevMsg = messages[index - 1];
+        // 如果前一条是 ToolMessage，它也会被纳入保留区，所以加入待匹配集合
+        if (prevMsg.type === 'tool') {
+            toolCallIdsInKeepRegion.add(prevMsg.tool_call_id);
+            index--;
+            continue;
+        }
+        // 如果前一条是 AIMessage 且有 tool_calls，检查它是否匹配保留区内的 ToolMessage
+        if (AIMessage.isInstance(prevMsg) && prevMsg.tool_calls?.length) {
+            const hasMatchingCall = prevMsg.tool_calls.some((call) => call.id && toolCallIdsInKeepRegion.has(call.id));
+            if (hasMatchingCall) {
+                // 这个 AIMessage 必须保留，index 前移
+                index--;
+                // 这个 AIMessage 可能还有其他 tool_calls，它们对应的 ToolMessage 也必须在保留区
+                for (const call of prevMsg.tool_calls) {
+                    if (call.id)
+                        toolCallIdsInKeepRegion.add(call.id);
+                }
+                continue;
+            }
+        }
+        break;
+    }
+    return index;
+}

package/dist/agent/db.d.ts

@@ -16,6 +16,7 @@ export interface MemorySearchResult {
     final_score: number;
 }
 export declare function searchMemories(query: string[], limit?: number): MemorySearchResult[];
+export declare function listRecentMemories(limit?: number): MemorySearchResult[];
 export declare function threadIdExists(threadId: string): boolean;
 export declare function initDb(): void;
 export declare function listRecentSessions(): SessionRow[];

package/dist/agent/db.js

@@ -55,6 +55,30 @@ export function searchMemories(query, limit = 10) {
         db.close();
     }
 }
+export function listRecentMemories(limit = 10) {
+    const db = new Database(DB_PATH);
+    try {
+        const rows = db.prepare(`
+      SELECT * FROM memory
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(limit);
+        return rows.map((r) => ({
+            id: r.id,
+            type: r.type,
+            content: r.content,
+            keywords: r.keywords,
+            importance: r.importance,
+            session_id: r.session_id,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            final_score: 0,
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
 export function threadIdExists(threadId) {
     const db = new Database(DB_PATH);
     try {

package/dist/agent/model.js

@@ -1,7 +1,7 @@
 import { ChatOpenAI } from '@langchain/openai';
 import { getModelConfig } from './config.js';
-const modelConfig = getModelConfig();
 export function createModel(options) {
+    const modelConfig = getModelConfig();
     const modelKwargs = {};
     if (modelConfig.model.startsWith('kimi') ||
         modelConfig.model.startsWith('minimax')) {
@@ -20,6 +20,7 @@ export function createModel(options) {
     });
 }
 export async function checkModel() {
+    const modelConfig = getModelConfig();
     if (modelConfig.apiKey.length < 20) {
         try {
             const model = createModel({ streaming: false });

package/dist/agent/prompt.d.ts

@@ -1 +1,2 @@
-export declare const systemPrompt: string;
+export declare function invalidateMemoryCache(): void;
+export declare function buildSystemPrompt(): string;

package/dist/agent/prompt.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { discoverSkills, getSkillsListText } from './skills.js';
 import { WORKSPACE_DIR } from './config.js';
+import { listRecentMemories } from './db.js';
 // ── Skills ────────────────────────────────────────────────
 discoverSkills();
 const skillsText = getSkillsListText();
@@ -56,13 +57,26 @@ When a user's request is a complex, multi-step task (such as data analysis, writ
 4. Only provide the final answer after all steps are done
 
 For simple, single-step tasks, do NOT use the todo list tools.`;
-export const systemPrompt = [
-    basePrompt,
-    profilePrompt,
-    memoryPrompt,
-    skillPrompt,
-    dateTimePrompt,
-    todoPrompt,
-]
-    .filter(Boolean)
-    .join('\n\n');
+let cachedMemories = null;
+export function invalidateMemoryCache() {
+    cachedMemories = null;
+}
+export function buildSystemPrompt() {
+    if (!cachedMemories) {
+        cachedMemories = listRecentMemories(10);
+    }
+    const memorySection = cachedMemories.length > 0
+        ? `## Recent Memories\n\n${cachedMemories.map((m) => `- ${m.content}`).join('\n')}`
+        : '';
+    return [
+        basePrompt,
+        profilePrompt,
+        memorySection,
+        memoryPrompt,
+        skillPrompt,
+        dateTimePrompt,
+        todoPrompt,
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}

package/dist/agent/tools/memory_create_tool.js

@@ -1,5 +1,6 @@
 import Database from 'better-sqlite3';
 import { DB_PATH } from '../db.js';
+import { invalidateMemoryCache } from '../prompt.js';
 const VALID_TYPES = ['fact', 'event', 'preference', 'skill'];
 export async function memoryCreateTool({ type, content, keywords, importance, }, config) {
     if (!VALID_TYPES.includes(type)) {
@@ -20,6 +21,7 @@ export async function memoryCreateTool({ type, content, keywords, importance, },
         const stmt = db.prepare(`INSERT INTO memory (type, content, keywords, importance, session_id)
        VALUES (?, ?, ?, ?, ?)`);
         stmt.run(type, trimmed, keywordsJson, importanceValue, sessionId);
+        invalidateMemoryCache();
         return 'Memory saved successfully.';
     }
     catch (err) {

package/dist/agent/tools/memory_delete_tool.js

@@ -1,5 +1,6 @@
 import Database from 'better-sqlite3';
 import { DB_PATH } from '../db.js';
+import { invalidateMemoryCache } from '../prompt.js';
 export async function memoryDeleteTool({ id, }, _config) {
     if (!Number.isFinite(id) || id <= 0) {
         return 'Error: id must be a positive integer.';
@@ -11,6 +12,7 @@ export async function memoryDeleteTool({ id, }, _config) {
             return `Error: no memory found with id ${id}.`;
         }
         db.prepare('DELETE FROM memory WHERE id = ?').run(id);
+        invalidateMemoryCache();
         return `Memory ${id} deleted successfully.`;
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zhitalk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A personal AI Agent like OpenClaw, including tools, skills, memory, hook, sub-agent, MCP server, etc. Run in the terminal.",
   "type": "module",
   "main": "dist/index.js",