zhitalk 0.0.12 → 0.1.1

package/dist/agent/agent.js

@@ -4,9 +4,10 @@ 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 { formatToolLog } from './colors.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';
 import { checkWritePermission } from './permission/write.js';
 import { checkExecPermission } from './permission/exec.js';
@@ -33,6 +34,10 @@ const StateAnnotation = Annotation.Root({
         reducer: (_prev, next) => next,
         default: () => 0,
     }),
+    todoList: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => null,
+    }),
 });
 // ── Graph Nodes ───────────────────────────────────────────
 function shouldContinue(state) {
@@ -121,7 +126,11 @@ function createAgentGraph(toolList) {
             }
             return true;
         });
-        const messages = [new SystemMessage(systemPrompt), ...modelMessages];
+        const messages = [new SystemMessage(buildSystemPrompt())];
+        if (state.todoList && state.todoList.length > 0) {
+            messages.push(new SystemMessage(`当前任务进度：\n${formatTodoListForPrompt(state.todoList)}`));
+        }
+        messages.push(...modelMessages);
         const response = await modelWithTheseTools.invoke(messages, config);
         return { messages: [response] };
     }
@@ -240,9 +249,25 @@ function createAgentGraph(toolList) {
                 }
             }));
         }
-        const allowOutputs = await executeCalls(allowCalls);
+        // 分离 todo 工具调用
+        const regularAllowCalls = [];
+        const todoAllowCalls = [];
+        for (const call of allowCalls) {
+            if (call.name === 'create_todo_list' || call.name === 'update_todo_status') {
+                todoAllowCalls.push(call);
+            }
+            else {
+                regularAllowCalls.push(call);
+            }
+        }
+        const regularOutputs = await executeCalls(regularAllowCalls);
+        const todoResult = processTodoCalls(todoAllowCalls, state.todoList);
+        if (todoResult.todoList && todoResult.todoList.length > 0) {
+            console.log(formatTodoList(todoResult.todoList));
+        }
+        const allowOutputs = [...regularOutputs, ...todoResult.messages];
         if (confirmCalls.length === 0) {
-            return { messages: [...allowOutputs, ...blockMessages] };
+            return { messages: [...allowOutputs, ...blockMessages], todoList: todoResult.todoList };
         }
         const result = interrupt({ toolCalls: confirmCalls });
         if (result !== 'approved') {
@@ -253,10 +278,11 @@ function createAgentGraph(toolList) {
             }));
             return {
                 messages: [...allowOutputs, ...blockMessages, ...deniedMessages],
+                todoList: todoResult.todoList,
             };
         }
         const confirmOutputs = await executeCalls(confirmCalls);
-        return { messages: [...allowOutputs, ...blockMessages, ...confirmOutputs] };
+        return { messages: [...allowOutputs, ...blockMessages, ...confirmOutputs], todoList: todoResult.todoList };
     }
     const workflow = new StateGraph(StateAnnotation)
         .addNode('model_request', modelRequest)
@@ -373,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/colors.d.ts

@@ -15,5 +15,11 @@ export declare const color: {
     warn: (text: string) => string;
     info: (text: string) => string;
     good: (text: string) => string;
+    todoTag: () => string;
 };
+export interface TodoDisplayItem {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+export declare function formatTodoList(items: TodoDisplayItem[]): string;
 export declare function formatToolLog(name: string, detail?: string): string;

package/dist/agent/colors.js

@@ -33,7 +33,25 @@ export const color = {
     warn: (text) => ck().yellow(text),
     info: (text) => ck().blueBright(text),
     good: (text) => ck().greenBright(text),
+    todoTag: () => ck().magentaBright('[Todo]'),
 };
+export function formatTodoList(items) {
+    const lines = [color.todoTag()];
+    for (const item of items) {
+        const symbol = item.status === 'completed'
+            ? color.good('✓')
+            : item.status === 'in_progress'
+                ? color.info('→')
+                : item.status === 'failed'
+                    ? color.error('✗')
+                    : color.gray('○');
+        const desc = item.status === 'completed' || item.status === 'failed'
+            ? color.gray(item.content)
+            : item.content;
+        lines.push(`  ${symbol} ${desc}`);
+    }
+    return '\n' + lines.join('\n') + '\n';
+}
 export function formatToolLog(name, detail) {
     const parts = [color.toolTag(), color.toolName(name), color.toolAction()];
     if (detail) {

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();
@@ -47,12 +48,35 @@ ${skillsText}`
 const skillPrompt = `## Skills
 
 ${skillList}\n\nNote: If you want to add a new skill, it must be placed in the ${path.join(WORKSPACE_DIR, 'skills')} directory.`;
-export const systemPrompt = [
-    basePrompt,
-    profilePrompt,
-    memoryPrompt,
-    skillPrompt,
-    dateTimePrompt,
-]
-    .filter(Boolean)
-    .join('\n\n');
+const todoPrompt = `## Task Planning
+
+When a user's request is a complex, multi-step task (such as data analysis, writing a document, planning a task, or any task clearly requiring more than 3 steps), you MUST:
+1. First call \`create_todo_list\` to create a structured plan with clear, actionable steps
+2. Then execute each step one by one
+3. After completing each step, call \`update_todo_status\` to mark it as completed (or failed if it didn't work)
+4. Only provide the final answer after all steps are done
+
+For simple, single-step tasks, do NOT use the todo list tools.`;
+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/todo.d.ts

@@ -0,0 +1,17 @@
+import { ToolMessage } from '@langchain/core/messages';
+export interface TodoItem {
+    id: number;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+interface TodoCall {
+    id?: string;
+    name: string;
+    args: Record<string, any>;
+}
+export declare function processTodoCalls(calls: TodoCall[], currentTodoList: TodoItem[] | null): {
+    messages: ToolMessage[];
+    todoList: TodoItem[] | null;
+};
+export declare function formatTodoListForPrompt(items: TodoItem[]): string;
+export {};

package/dist/agent/todo.js

@@ -0,0 +1,86 @@
+import { ToolMessage } from '@langchain/core/messages';
+export function processTodoCalls(calls, currentTodoList) {
+    const messages = [];
+    let todoList = currentTodoList;
+    for (const call of calls) {
+        if (call.name === 'create_todo_list') {
+            const items = call.args.items;
+            if (!Array.isArray(items) || items.length === 0) {
+                messages.push(new ToolMessage({
+                    content: 'Error: items must be a non-empty array.',
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            todoList = items.map((content, i) => ({
+                id: i,
+                content: typeof content === 'string' ? content.trim() : String(content),
+                status: 'pending',
+            }));
+            messages.push(new ToolMessage({
+                content: 'Todo list created successfully.',
+                tool_call_id: call.id ?? '',
+                name: call.name,
+            }));
+        }
+        else if (call.name === 'update_todo_status') {
+            const index = call.args.index;
+            const status = call.args.status;
+            if (!todoList) {
+                messages.push(new ToolMessage({
+                    content: 'Error: no todo list exists.',
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            if (typeof index !== 'number' ||
+                !Number.isInteger(index) ||
+                index < 0 ||
+                index >= todoList.length) {
+                messages.push(new ToolMessage({
+                    content: `Error: index ${index} is out of range.`,
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            const validStatuses = [
+                'pending',
+                'in_progress',
+                'completed',
+                'failed',
+            ];
+            if (!validStatuses.includes(status)) {
+                messages.push(new ToolMessage({
+                    content: `Error: invalid status "${status}".`,
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            todoList[index].status = status;
+            messages.push(new ToolMessage({
+                content: `Todo item ${index} updated to ${status}.`,
+                tool_call_id: call.id ?? '',
+                name: call.name,
+            }));
+        }
+    }
+    return { messages, todoList };
+}
+export function formatTodoListForPrompt(items) {
+    return items
+        .map((item) => {
+        const statusMark = item.status === 'completed'
+            ? '[x]'
+            : item.status === 'in_progress'
+                ? '[~]'
+                : item.status === 'failed'
+                    ? '[!]'
+                    : '[ ]';
+        return `${statusMark} ${item.content}`;
+    })
+        .join('\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/dist/agent/tools.js

@@ -145,6 +145,35 @@ const agentTool = createZhitalkTool(agentToolImpl, {
             .describe('A clear, self-contained task prompt for the sub-agent. It should include all necessary context because the sub-agent cannot see the current conversation history.'),
     }),
 }, 'exec');
+async function createTodoListDummy() {
+    return 'Error: create_todo_list should be handled internally by the agent.';
+}
+async function updateTodoStatusDummy() {
+    return 'Error: update_todo_status should be handled internally by the agent.';
+}
+const createTodoListTool = createZhitalkTool(createTodoListDummy, {
+    name: 'create_todo_list',
+    description: 'Create a structured todo list for a complex, multi-step task. Must be called BEFORE starting execution. Each item should be a clear, actionable step.',
+    schema: z.object({
+        items: z
+            .array(z.string().describe('A single todo item description.'))
+            .describe('The list of todo items to create. Each item should be a clear, actionable step.'),
+    }),
+}, 'read');
+const updateTodoStatusTool = createZhitalkTool(updateTodoStatusDummy, {
+    name: 'update_todo_status',
+    description: 'Update the status of a todo item in the current todo list. Call this after completing EACH step.',
+    schema: z.object({
+        index: z
+            .number()
+            .int()
+            .min(0)
+            .describe('The zero-based index of the todo item to update.'),
+        status: z
+            .enum(['in_progress', 'completed', 'failed'])
+            .describe('The new status of the todo item.'),
+    }),
+}, 'read');
 export async function maybePersistedOutput(content, toolCallId) {
     const MAX_LENGTH = 50000;
     if (content.length <= MAX_LENGTH) {
@@ -180,6 +209,8 @@ export const nativeTools = [
     memoryDeleteTool,
     profileUpdateTool,
     agentTool,
+    createTodoListTool,
+    updateTodoStatusTool,
 ];
 export let tools = [...nativeTools];
 export async function initTools() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zhitalk",
-  "version": "0.0.12",
+  "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",