@vietor/easy-agent 0.6.3 → 0.7.0

package/README.md

@@ -1,6 +1,6 @@
 # @vietor/easy-agent
 
-Terminal-based AI agent CLI with a conversational TUI, powered by `@vietor/easy-agent-core`.
+Terminal-based AI agent CLI with a conversational TUI, powered by `@vietor/agent-core`.
 
 ## Requirements
 
@@ -30,20 +30,20 @@ Create `~/.easy-agent.json` in your home directory:
     "baseUrl": "https://api.deepseek.com/v1",
     "apiKey": "your-api-key",
     "model": "deepseek-v4-flash",
-    "reasoningEffort": "high"
+    "thinkingEffort": "high"
   }
 }
 ```
 
 `llm.baseUrl`, `llm.apiKey`, and `llm.model` are all required. Point `baseUrl` at any OpenAI-compatible endpoint (OpenAI, Azure OpenAI, local servers, etc.) and set `model` to a model that endpoint serves.
 
-#### `wireApi` (optional)
+#### `backend` (optional)
 
 Selects the wire protocol the client speaks. Valid values: `"completions"` | `"anthropic"` | `"responses"`. Defaults to `"completions"`.
 
-- `"completions"` - OpenAI Chat Completions compatible endpoint (the default). `reasoningEffort` is sent as `reasoning_effort`.
-- `"anthropic"` - Anthropic Messages API via the official SDK. Point `baseUrl` at an Anthropic-compatible endpoint (e.g. `https://api.anthropic.com`) and `model` at a Claude model. `reasoningEffort` enables extended thinking (`"high"` = 16k budget, `"max"` = 32k).
-- `"responses"` - OpenAI Responses API via the official SDK. `reasoningEffort` is sent as `reasoning.effort`, with reasoning summaries streamed to the UI.
+- `"completions"` - OpenAI Chat Completions compatible endpoint (the default). `thinkingEffort` is sent as `reasoning_effort`.
+- `"anthropic"` - Anthropic Messages API via the official SDK. Point `baseUrl` at an Anthropic-compatible endpoint (e.g. `https://api.anthropic.com`) and `model` at a Claude model. `thinkingEffort` enables extended thinking (`"high"` = 16k budget, `"max"` = 32k).
+- `"responses"` - OpenAI Responses API via the official SDK. `thinkingEffort` is sent as `reasoning.effort`, with reasoning summaries streamed to the UI.
 
 ```json
 {
@@ -51,15 +51,15 @@ Selects the wire protocol the client speaks. Valid values: `"completions"` | `"a
     "baseUrl": "https://api.anthropic.com",
     "apiKey": "your-api-key",
     "model": "claude-sonnet-5",
-    "wireApi": "anthropic",
-    "reasoningEffort": "high"
+    "backend": "anthropic",
+    "thinkingEffort": "high"
   }
 }
 ```
 
-#### `reasoningEffort` (optional)
+#### `thinkingEffort` (optional)
 
-Controls the depth of model reasoning. Valid values: `"high"` | `"max"`. Defaults to `"high"`. When set to `"max"` the model spends more tokens on deeper reasoning before responding — useful for complex logic, math, or multi-step analysis. The current setting is shown in the TUI header (e.g. ` · reasoning max`). Requires a model that supports the `reasoning_effort` parameter.
+Controls the depth of model thinking. Valid values: `"high"` | `"max"`. Defaults to `"high"`. When set to `"max"` the model spends more tokens on deeper thinking before responding — useful for complex logic, math, or multi-step analysis. The current setting is shown in the TUI header (e.g. ` · thinking max`). Requires a model that supports the `reasoning_effort` parameter.
 
 ### Proxy
 
@@ -141,9 +141,9 @@ easy-agent --resume      # list all saved sessions for this directory
 
 Type a prompt and press Enter. The agent streams its reply and calls tools as needed, showing each tool call and a one-line summary of its result. It iterates until the task is done (capped at 50 tool rounds per turn).
 
-The TUI header shows the model name, version, and configured reasoning effort (e.g. `deepseek-v4-flash · reasoning high`). While the agent is running, a spinner displays the thinking and reply elapsed time alongside token counts (e.g. `⠋ thinking · think 2s · reply 0s · ↑1.2k · ↓0.4k`). If the LLM emits extended thinking blocks, a collapsible reasoning panel appears — press <kbd>t</kbd> to expand/collapse it.
+The TUI header shows the model name, version, and configured thinking effort (e.g. `deepseek-v4-flash · thinking high`). While the agent is running, a spinner displays the thinking and reply elapsed time alongside token counts (e.g. `⠋ thinking · think 2s · reply 0s · ↑1.2k · ↓0.4k`). If the LLM emits extended thinking blocks, a collapsible thinking panel appears — press <kbd>t</kbd> to expand/collapse it.
 
-A status bar at the bottom shows the context token usage with a progress bar and percentage, along with keyboard shortcut hints: <kbd>ESC</kbd> to abort a running task, <kbd>t</kbd> to toggle reasoning (when available), and <kbd>/</kbd> for commands.
+A status bar at the bottom shows the context token usage with a progress bar and percentage, along with keyboard shortcut hints: <kbd>ESC</kbd> to abort a running task, <kbd>t</kbd> to toggle thinking (when available), and <kbd>/</kbd> for commands.
 
 ### Built-in tools
 
@@ -155,7 +155,7 @@ A status bar at the bottom shows the context token usage with a progress bar and
 - **Grep** — search file contents by regex with `glob`/`type` filters, context lines, case-insensitive, and `files_with_matches`/`count` output modes.
 - **WebFetch** — fetch a URL as markdown or text.
 - **AskUser** — ask the user a question and wait for their answer.
-- **TodoWrite** — track multi-step work as a task list (pending / in_progress / completed), shown live as a panel in the TUI.
+- **TodoWrite** — track multi-step work as a task list (pending / inProgress / completed), shown live as a panel in the TUI.
 - **SubAgent** — delegate investigation (`explore`) or implementation-planning (`plan`) subtasks to a nested read-only sub-agent.
 
 ### Slash commands
@@ -166,8 +166,8 @@ A status bar at the bottom shows the context token usage with a progress bar and
 | `/clear` | Reset the conversation |
 | `/compact` | Compress the conversation into a summary to free context |
 | `/skill` | List available skills |
-| `/export` | Save the current conversation to `conversation-{timestamp}.jsonl` |
-| `/quit` or `/exit` | Leave the app |
+| `/save` | Save the current session to `session-{timestamp}.jsonl` |
+| `/exit` | Leave the app |
 
 ## Build from source
 

package/dist/commands/builtin.js

@@ -1,7 +1,7 @@
 import { writeFileSync } from "node:fs";
 export const clearCommand = {
     name: "clear",
-    description: "Clear the conversation and log",
+    description: "Clear the session and log",
     async execute(ctx) {
         ctx.session.clear();
     },
@@ -48,30 +48,23 @@ export const exitCommand = {
     name: "exit",
     description: "Exit the conversation",
     async execute(ctx) {
-        ctx.session.localStore.set("exitRequested", true);
+        ctx.requestExit();
     },
 };
-export const exportCommand = {
-    name: "export",
-    description: "Export the conversation to a JSONL file",
+export const saveCommand = {
+    name: "save",
+    description: "Save the session to a JSONL file",
     async execute(ctx) {
         const d = new Date();
         const pad = (n) => String(n).padStart(2, "0");
         const ts = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-        const file = `conversation-${ts}.jsonl`;
+        const file = `session-${ts}.jsonl`;
         const lines = ctx.session
             .export()
             .map((m) => JSON.stringify(m))
             .join("\n");
         writeFileSync(file, lines + "\n", "utf-8");
-        ctx.message(`exported to ${file}`);
-    },
-};
-export const quitCommand = {
-    name: "quit",
-    description: "Exit the conversation",
-    async execute(ctx) {
-        ctx.session.localStore.set("exitRequested", true);
+        ctx.message(`saved to ${file}`);
     },
 };
 export const builtinCommands = [
@@ -80,6 +73,5 @@ export const builtinCommands = [
     compactCommand,
     skillCommand,
     exitCommand,
-    quitCommand,
-    exportCommand,
+    saveCommand,
 ];

package/dist/commands/dispatch.js

@@ -1,29 +1,32 @@
-import { errorMessage } from "@vietor/easy-agent-core";
+import { toErrorMessage } from "@vietor/agent-core/util";
 import { builtinCommands } from "./builtin.js";
 const commands = new Map(builtinCommands.map((c) => [c.name, c]));
-export async function executeCommand(name, session) {
+export async function executeSlashCommand(name, session, requestExit, persist) {
     const cmd = commands.get(name);
     if (cmd) {
-        const ctx = { session, message: session.timelineNotice, error: session.timelineError };
+        const ctx = { session, message: session.addNotice, error: session.addError, requestExit };
         try {
             await cmd.execute(ctx);
         }
         catch (e) {
-            ctx.error(errorMessage(e));
+            ctx.error(toErrorMessage(e));
         }
+        persist();
         return;
     }
     try {
-        if (await session.runSkill(name))
+        if (await session.runSkill(name)) {
+            persist();
             return;
+        }
     }
     catch (e) {
-        session.timelineError(errorMessage(e));
+        session.addError(toErrorMessage(e));
         return;
     }
-    session.timelineError(`unknown command: /${name}`);
+    session.addError(`unknown command: /${name}`);
 }
-export function commandSchemas(session) {
+export function slashCommandInfos(session) {
     const map = new Map();
     for (const c of builtinCommands)
         map.set(c.name, { name: c.name, description: c.description });

package/dist/config.js

@@ -2,19 +2,20 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
-const CONFIG_FILE = ".easy-agent.json";
+import { DEFAULT_BACKEND, DEFAULT_MAX_INPUT_TOKENS, DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_THINKING_EFFORT } from "@vietor/agent-core/util";
+const CONFIG_PATH = ".easy-agent.json";
 const LLMConfigSchema = z.object({
     baseUrl: z.string(),
     apiKey: z.string(),
     model: z.string(),
-    reasoningEffort: z.enum(["high", "max"]).default("high"),
-    wireApi: z.enum(["completions", "anthropic", "responses"]).default("completions"),
-    maxInputTokens: z.number().int().positive().default(1_000_000),
-    maxOutputTokens: z.number().int().positive().default(128_000),
+    thinkingEffort: z.enum(["high", "max"]).default(DEFAULT_THINKING_EFFORT),
+    backend: z.enum(["completions", "anthropic", "responses"]).default(DEFAULT_BACKEND),
+    maxInputTokens: z.number().int().positive().default(DEFAULT_MAX_INPUT_TOKENS),
+    maxOutputTokens: z.number().int().positive().default(DEFAULT_MAX_OUTPUT_TOKENS),
 });
 const MCPServerConfigSchema = z.union([
     z.object({
-        type: z.literal("stdio").optional(),
+        type: z.literal("stdio").default("stdio"),
         command: z.string(),
         args: z.array(z.string()).optional(),
         env: z.record(z.string(), z.string()).optional(),
@@ -32,27 +33,27 @@ const ConfigSchema = z.object({
     mcpServers: z.record(z.string(), MCPServerConfigSchema).optional(),
 });
 export function loadConfig() {
-    const path = join(homedir(), CONFIG_FILE);
+    const path = join(homedir(), CONFIG_PATH);
     let raw;
     try {
         raw = readFileSync(path, "utf-8");
     }
     catch {
-        throw new Error(`Config not found: create ~/${CONFIG_FILE} (see README for format).`);
+        throw new Error(`Config not found: create ~/${CONFIG_PATH} (see README for format).`);
     }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        throw new Error(`Invalid JSON in ~/${CONFIG_FILE}.`);
+        throw new Error(`Invalid JSON in ~/${CONFIG_PATH}.`);
     }
     const result = ConfigSchema.safeParse(parsed);
     if (!result.success) {
         const issues = result.error.issues
             .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
             .join("\n  ");
-        throw new Error(`Invalid config ~/${CONFIG_FILE}:\n  ${issues}`);
+        throw new Error(`Invalid config ~/${CONFIG_PATH}:\n  ${issues}`);
     }
     return result.data;
 }

package/dist/main.js

@@ -3,10 +3,11 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "./config.js";
-import { tryLoadSkills, tryReadFileText, createSession, SYSTEM_PROMPT_BOUNDARY } from "@vietor/easy-agent-core";
+import { createSession, SYSTEM_PROMPT_BOUNDARY, tryLoadSkills } from "@vietor/agent-core";
+import { tryReadFileText } from "@vietor/agent-core/util";
 import { startApp } from "./tui/app.js";
 import { getPackageInfo } from "./util/package.js";
-import { FileSessionPersistence } from "./session-store.js";
+import { FileSessionPersistence } from "./session-persistence.js";
 function buildSystemPromptBase(cwd) {
     return [
         "You are Easy Agent, an autonomous assistant. You complete tasks by calling tools, inspecting their results, and iterating until the work is done.",
@@ -23,7 +24,15 @@ function buildSystemPromptBase(cwd) {
 - Trust tool results as ground truth.`,
     ].join("\n\n");
 }
-async function listSessions(store) {
+function assembleSystemPrompt(cwd) {
+    const globalPrompt = tryReadFileText(join(homedir(), ".easy-agent", "AGENTS.md")) ??
+        tryReadFileText(join(homedir(), ".claude", "CLAUDE.md"));
+    const projectPrompt = tryReadFileText(join(cwd, "AGENTS.md")) ?? tryReadFileText(join(cwd, "CLAUDE.md"));
+    return [buildSystemPromptBase(cwd), globalPrompt, projectPrompt]
+        .filter(Boolean)
+        .join(SYSTEM_PROMPT_BOUNDARY);
+}
+async function listSessions(store, name) {
     const sessions = await store.listSessions();
     if (!sessions.length) {
         console.log("No previous sessions found in this directory.");
@@ -34,7 +43,7 @@ async function listSessions(store) {
         const title = s.title ? `  ${s.title}` : "";
         console.log(`  ${s.id}  ${new Date(s.updatedAt).toLocaleString()}${title}`);
     }
-    console.log("\nResume with: easy-agent --resume <id>");
+    console.log(`\nResume with: ${name} --resume <id>`);
 }
 export async function main(argv = []) {
     const pkg = getPackageInfo();
@@ -50,7 +59,7 @@ export async function main(argv = []) {
     const cwd = process.cwd();
     const store = new FileSessionPersistence(cwd);
     if (opts.resume !== undefined && typeof opts.resume !== "string") {
-        await listSessions(store);
+        await listSessions(store, program.name());
         return;
     }
     const config = loadConfig();
@@ -70,48 +79,49 @@ export async function main(argv = []) {
     if (!sessionId)
         sessionId = randomUUID();
     const globalSkills = tryLoadSkills(join(homedir(), ".easy-agent", "skills")) ?? tryLoadSkills(join(homedir(), ".claude", "skills"));
-    const globalPrompt = tryReadFileText(join(homedir(), ".easy-agent", "AGENTS.md")) ??
-        tryReadFileText(join(homedir(), ".claude", "CLAUDE.md"));
-    const projectPrompt = tryReadFileText(join(cwd, "AGENTS.md")) ?? tryReadFileText(join(cwd, "CLAUDE.md"));
-    const systemPrompt = [buildSystemPromptBase(cwd), globalPrompt, projectPrompt]
-        .filter(Boolean)
-        .join(SYSTEM_PROMPT_BOUNDARY);
+    const systemPrompt = assembleSystemPrompt(cwd);
     const session = await createSession({
         systemPrompt,
-        llmConfig: config.llm,
+        llm: config.llm,
         mcpServers: config.mcpServers,
         skills: globalSkills,
-        builtinTools: {
+        builtInTools: {
             askUser: true,
             todoWrite: true,
             subAgent: true,
         },
         cwd: cwd,
         sessionId,
-        persistence: store,
+        clientInfo: { name: pkg.name, version: pkg.version },
     });
     if (resume) {
-        const restored = await session.restore();
-        if (!restored) {
+        const state = await store.load(sessionId);
+        if (!state) {
             console.error(`Session not found: ${sessionId}`);
             process.exit(1);
         }
+        session.importState(state);
     }
+    let saveChain = Promise.resolve();
+    const persist = () => {
+        const state = session.exportState();
+        saveChain = saveChain.catch(() => { }).then(() => store.saveAll(sessionId, state));
+    };
     let shuttingDown = false;
     const shutdown = () => {
         if (shuttingDown)
             process.exit(1);
         shuttingDown = true;
         session.dispose();
-        session.flush().catch(() => { }).finally(() => process.exit(0));
+        saveChain.catch(() => { }).finally(() => process.exit(0));
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
     process.stdout.write("");
-    const app = startApp(session);
+    const app = startApp(session, persist);
     await app.waitUntilExit().finally(async () => {
         session.dispose();
-        await session.flush();
-        console.log(["Resume this session with:", `easy-agent --resume ${sessionId}`].join("\n"));
+        await saveChain;
+        console.log(["Resume this session with:", `${program.name()} --resume ${sessionId}`].join("\n"));
     });
 }

package/dist/{session-store.js → session-persistence.js}

@@ -1,8 +1,12 @@
 import { appendFile, writeFile } from "node:fs/promises";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, statSync } from "node:fs";
+import { isDeepStrictEqual } from "node:util";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { ellipsisText, MAX_SUMMARY_LENGTH } from "@vietor/easy-agent-core";
+import {} from "@vietor/agent-core";
+import { summarizeText } from "@vietor/agent-core/util";
+const MAX_TITLE_LENGTH = 75;
+const MAX_TITLE_SCAN_BYTES = 64 * 1024;
 function encodeCwd(cwd) {
     return cwd.replace(/[\/\\:]/g, "-");
 }
@@ -18,10 +22,22 @@ function parseJsonLines(text) {
     }
     return out;
 }
+function readFilePrefix(path, maxBytes) {
+    const fd = openSync(path, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(maxBytes);
+        const n = readSync(fd, buffer, 0, maxBytes, 0);
+        return buffer.subarray(0, n).toString("utf-8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 export class FileSessionPersistence {
     cwd;
     dir;
     writtenCounts = new Map();
+    writtenTodos = new Map();
     constructor(cwd) {
         this.cwd = cwd;
         this.dir = join(homedir(), ".easy-agent", "projects", encodeCwd(cwd));
@@ -46,6 +62,7 @@ export class FileSessionPersistence {
                 todos = r.todos;
         }
         this.writtenCounts.set(sessionId, messages.length);
+        this.writtenTodos.set(sessionId, todos);
         return { messages, todos };
     }
     async saveAll(sessionId, state) {
@@ -54,8 +71,13 @@ export class FileSessionPersistence {
         const shrink = state.messages.length < written;
         const lines = state.messages
             .slice(shrink ? 0 : written)
-            .map((m) => JSON.stringify({ t: "message", m }))
-            .concat([JSON.stringify({ t: "todo", todos: state.todos })]);
+            .map((m) => JSON.stringify({ t: "message", m }));
+        const lastTodos = this.writtenTodos.get(sessionId);
+        if (shrink || lastTodos === undefined || !isDeepStrictEqual(lastTodos, state.todos)) {
+            lines.push(JSON.stringify({ t: "todo", todos: state.todos }));
+        }
+        if (lines.length === 0)
+            return;
         const path = this.file(sessionId);
         if (shrink) {
             await writeFile(path, lines.join("\n") + "\n", "utf-8");
@@ -64,6 +86,7 @@ export class FileSessionPersistence {
             await appendFile(path, lines.join("\n") + "\n", "utf-8");
         }
         this.writtenCounts.set(sessionId, state.messages.length);
+        this.writtenTodos.set(sessionId, state.todos);
     }
     async listSessions() {
         if (!existsSync(this.dir))
@@ -92,10 +115,10 @@ export class FileSessionPersistence {
         const first = this.readFirstUser(path);
         if (!first)
             return undefined;
-        return ellipsisText(first, MAX_SUMMARY_LENGTH);
+        return summarizeText(first, MAX_TITLE_LENGTH);
     }
     readFirstUser(path) {
-        const first = parseJsonLines(readFileSync(path, "utf-8"))
+        const first = parseJsonLines(readFilePrefix(path, MAX_TITLE_SCAN_BYTES))
             .find((r) => r.t === "message" && r.m && r.m.role === "user" && typeof r.m.content === "string");
         return first?.m?.content;
     }

package/dist/tui/app-header.js

@@ -2,9 +2,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { memo } from "react";
 import { Box, Text, useWindowSize } from "ink";
 import { getPackageInfo } from "../util/package.js";
-export const AppHeader = memo(function AppHeader({ cwd, model, reasoningEffort }) {
+export const AppHeader = memo(function AppHeader({ cwd, model, thinkingEffort }) {
     const { columns } = useWindowSize();
     const pkg = getPackageInfo();
-    const reasoning = ` · reasoning ${reasoningEffort}`;
-    return (_jsxs(Box, { width: columns, paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Easy Agent" }), _jsxs(Text, { dimColor: true, children: [" v", pkg.version] })] }), _jsx(Text, { dimColor: true, children: `${model}${reasoning}` })] }), _jsx(Text, { dimColor: true, children: cwd })] }));
+    const thinking = ` · thinking ${thinkingEffort}`;
+    return (_jsxs(Box, { width: columns, paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Easy Agent" }), _jsxs(Text, { dimColor: true, children: [" v", pkg.version] })] }), _jsx(Text, { dimColor: true, children: `${model}${thinking}` })] }), _jsx(Text, { dimColor: true, children: cwd })] }));
 });

package/dist/tui/app.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Box, render, Text, useApp, useInput, useWindowSize } from "ink";
-import { createRunState, errorMessage } from "@vietor/easy-agent-core";
-import { executeCommand, commandSchemas } from "../commands/dispatch.js";
+import { INITIAL_RUN_METRICS } from "@vietor/agent-core";
+import { toErrorMessage } from "@vietor/agent-core/util";
+import { executeSlashCommand, slashCommandInfos } from "../commands/dispatch.js";
 import { Markdown } from "./components/markdown.js";
 import { TimelineView } from "./timeline-view.js";
 import { TodoView } from "./todo-view.js";
@@ -31,88 +32,89 @@ function useThrottledText(frameMs) {
     };
     return { text, append, reset };
 }
-export function App({ session }) {
-    const { exit } = useApp();
-    const { columns } = useWindowSize();
-    const view = useSyncExternalStore(session.subscribe, session.getSnapshot);
-    const [runState, setRunState] = useState(createRunState);
+function useSessionStream(session) {
+    const [runMetrics, setRunMetrics] = useState(INITIAL_RUN_METRICS);
     const streaming = useThrottledText(STREAM_FRAME_MS);
-    const reasoning = useThrottledText(STREAM_FRAME_MS);
-    const [showReasoning, setShowReasoning] = useState(false);
-    const allCmds = useMemo(() => commandSchemas(session), [session]);
-    const pendingQuestion = session.getPendingQuestion();
+    const thinking = useThrottledText(STREAM_FRAME_MS);
+    const [showThinking, setShowThinking] = useState(false);
     useEffect(() => {
-        const unsub = session.subscribeEvents((e) => {
+        const unsub = session.onEvent((e) => {
             switch (e.type) {
                 case "assistant_delta":
                     streaming.append(e.text);
                     break;
-                case "reasoning_delta":
-                    reasoning.append(e.text);
+                case "thinking_delta":
+                    thinking.append(e.text);
                     break;
-                case "reasoning_clear":
-                    reasoning.reset();
+                case "thinking_cleared":
+                    thinking.reset();
                     break;
                 case "assistant":
-                    streaming.reset();
-                    break;
                 case "retry":
                 case "interrupted":
                     streaming.reset();
                     break;
-                case "run_state":
-                    setRunState(e);
+                case "run_metrics":
+                    setRunMetrics(e);
                     break;
             }
         });
         return unsub;
-    }, []);
+    }, [session]);
+    return { runMetrics, streaming, thinking, showThinking, setShowThinking };
+}
+export function App({ session, persist }) {
+    const { exit } = useApp();
+    const { columns } = useWindowSize();
+    const view = useSyncExternalStore(session.subscribe, session.getSnapshot);
+    const { runMetrics, streaming, thinking, showThinking, setShowThinking } = useSessionStream(session);
+    const allCmds = useMemo(() => slashCommandInfos(session), [session]);
+    const pendingQuestion = session.pendingQuestion;
     useInput((_input, key) => {
         if (pendingQuestion) {
             if (key.ctrl && _input === "c")
                 session.abort();
             return;
         }
-        if (_input === "t" && runState.running && reasoning.text) {
-            setShowReasoning((v) => !v);
+        if (_input === "t" && runMetrics.running && thinking.text) {
+            setShowThinking((v) => !v);
             return;
         }
         if (key.escape) {
             session.abort();
         }
         else if (key.ctrl && _input === "c") {
-            if (runState.running)
+            if (runMetrics.running)
                 session.abort();
             else
                 exit();
         }
     });
     async function handleCommand(name) {
-        await executeCommand(name, session);
-        if (session.localStore.get("exitRequested") != null)
-            exit();
+        await executeSlashCommand(name, session, exit, persist);
     }
     async function handlePrompt(text) {
         try {
-            await session.startPrompt(text);
+            await session.prompt(text);
+            persist();
         }
         catch (e) {
-            session.timelineError(errorMessage(e));
+            session.addError(toErrorMessage(e));
         }
     }
     let runningView = null;
-    if (runState.running) {
+    if (runMetrics.running) {
         if (pendingQuestion) {
             runningView = (_jsx(QuestionView, { question: pendingQuestion, onAnswer: (ans) => session.submitAnswer(pendingQuestion.id, ans) }));
         }
         else {
             const spinnerLabel = streaming.text ? "replying" : "working";
-            runningView = (_jsxs(_Fragment, { children: [reasoning.text ? renderReasoning(reasoning.text, showReasoning) : null, streaming.text ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, paddingRight: 1, children: _jsx(Markdown, { children: streaming.text }) })) : null, _jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: spinnerLabel, thinkingElapsed: runState.thinkingElapsed, replyElapsed: runState.replyElapsed, inputTokens: runState.inputTokens, outputTokens: runState.outputTokens }) })] }));
+            runningView = (_jsxs(_Fragment, { children: [thinking.text ? renderThinking(thinking.text, showThinking) : null, streaming.text ? (_jsx(Box, { marginTop: 1, paddingLeft: 1, paddingRight: 1, children: _jsx(Markdown, { children: streaming.text }) })) : null, _jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsx(Spinner, { label: spinnerLabel, thinkingElapsed: runMetrics.thinkingElapsed, replyElapsed: runMetrics.replyElapsed, inputTokens: runMetrics.inputTokens, outputTokens: runMetrics.outputTokens }) })] }));
         }
     }
-    return (_jsxs(Box, { width: columns, flexDirection: "column", children: [_jsx(AppHeader, { cwd: session.cwd, model: session.model, reasoningEffort: session.reasoningEffort }), view.timeline.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: view.timeline.map((entry, i) => (_jsx(TimelineView, { entry: entry }, i))) })) : null, runningView, view.todos.length > 0 ? _jsx(TodoView, { todos: view.todos }) : null, !runState.running ? (_jsx(PromptOrCommandInput, { commands: allCmds, onCommand: handleCommand, onPrompt: handlePrompt })) : null, _jsx(StatusBar, { contextTokens: session.contextTokens, contextLimit: session.compactThreshold, running: runState.running, questionPending: !!pendingQuestion, reasoningAvailable: !!reasoning.text })] }));
+    return (_jsxs(Box, { width: columns, flexDirection: "column", children: [_jsx(AppHeader, { cwd: session.cwd, model: session.model, thinkingEffort: session.thinkingEffort }), view.timeline.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: view.timeline.map((entry, i) => (_jsx(TimelineView, { entry: entry }, i))) })) : null, runningView, view.todos.length > 0 ? _jsx(TodoView, { todos: view.todos }) : null, !runMetrics.running ? (_jsx(PromptOrCommandInput, { commands: allCmds, onCommand: handleCommand, onPrompt: handlePrompt })) : null, _jsx(StatusBar, { contextTokens: session.contextTokens, contextLimit: session.contextLimit, running: runMetrics.running, questionPending: !!pendingQuestion, thinkingAvailable: !!thinking.text })] }));
 }
-function renderReasoning(text, expanded) {
+function renderThinking(text, expanded) {
     const lines = text.split("\n");
     const firstLine = (lines[0] ?? "").slice(0, 80);
     if (expanded) {
@@ -121,6 +123,6 @@ function renderReasoning(text, expanded) {
     const extra = lines.length > 1 ? ` …+${lines.length - 1} lines` : "";
     return (_jsx(Box, { marginTop: 1, paddingLeft: 1, children: _jsxs(Text, { dimColor: true, children: ["\u250A ", firstLine, extra, " (t to expand)"] }) }));
 }
-export function startApp(session) {
-    return render(_jsx(App, { session: session }), { exitOnCtrlC: false, incrementalRendering: true });
+export function startApp(session, persist) {
+    return render(_jsx(App, { session: session, persist: persist }), { exitOnCtrlC: false, incrementalRendering: true });
 }

package/dist/tui/spinner.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { Text } from "ink";
-import { formatSeconds, formatCompactNumber } from "@vietor/easy-agent-core";
+import { formatCompactNumber, formatDuration } from "@vietor/agent-core/util";
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 export function Spinner({ label, thinkingElapsed, replyElapsed, inputTokens, outputTokens, }) {
     const [frame, setFrame] = useState(0);
@@ -9,5 +9,5 @@ export function Spinner({ label, thinkingElapsed, replyElapsed, inputTokens, out
         const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
         return () => clearInterval(id);
     }, []);
-    return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: SPINNER_FRAMES[frame] }), _jsxs(Text, { children: [" ", label] }), _jsxs(Text, { dimColor: true, children: [" \u00B7 work ", formatSeconds(thinkingElapsed), " \u00B7 reply ", formatSeconds(replyElapsed), " \u00B7 \u2191", formatCompactNumber(inputTokens), " \u00B7 \u2193", formatCompactNumber(outputTokens)] })] }));
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: SPINNER_FRAMES[frame] }), _jsxs(Text, { children: [" ", label] }), _jsxs(Text, { dimColor: true, children: [" \u00B7 work ", formatDuration(thinkingElapsed), " \u00B7 reply ", formatDuration(replyElapsed), " \u00B7 \u2191", formatCompactNumber(inputTokens), " \u00B7 \u2193", formatCompactNumber(outputTokens)] })] }));
 }

package/dist/tui/status-bar.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { memo } from "react";
 import { Box, Text, useWindowSize } from "ink";
-import { formatCompactNumber } from "@vietor/easy-agent-core";
-export const StatusBar = memo(function StatusBar({ contextTokens, contextLimit, running, questionPending, reasoningAvailable }) {
+import { formatCompactNumber } from "@vietor/agent-core/util";
+export const StatusBar = memo(function StatusBar({ contextTokens, contextLimit, running, questionPending, thinkingAvailable }) {
     const { columns } = useWindowSize();
     const pct = Math.min(100, contextLimit > 0 ? Math.round((contextTokens / contextLimit) * 100) : 0);
     const filled = Math.round((pct / 100) * 10);
@@ -12,7 +12,7 @@ export const StatusBar = memo(function StatusBar({ contextTokens, contextLimit,
     if (questionPending)
         hints = "↑↓ select · enter confirm · esc skip";
     else if (running)
-        hints = reasoningAvailable ? "esc stop · t reasoning" : "esc stop";
+        hints = thinkingAvailable ? "esc stop · t thinking" : "esc stop";
     else
         hints = "/ commands";
     return (_jsxs(Box, { width: columns, paddingX: 1, flexDirection: "row", justifyContent: "space-between", borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: `context ${formatCompactNumber(contextTokens)} ` }), _jsx(Text, { color: ctxColor, children: `▕${bar}▏ ${pct}%` })] }), _jsx(Text, { dimColor: true, children: hints })] }));

package/dist/tui/timeline-view.js

@@ -10,7 +10,7 @@ export const TimelineView = memo(function TimelineView({ entry }) {
             return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "magenta", children: "\u25C8 " }), _jsx(Text, { dimColor: true, children: "skill " }), _jsx(Text, { color: "magenta", bold: true, children: entry.name })] }) }));
         case "assistant":
             return (_jsx(Box, { marginTop: 1, children: _jsx(Markdown, { children: entry.text }) }));
-        case "tool_start":
+        case "tool":
             return _jsx(ToolEntry, { entry: entry });
         case "retry":
             return (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "\u21BB " }), _jsxs(Text, { dimColor: true, children: ["retry ", entry.attempt, "/", entry.max, " \u00B7 ", entry.reason] })] }) }));

package/dist/tui/todo-view.js

@@ -1,15 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { memo } from "react";
 import { Box, Text } from "ink";
-import {} from "@vietor/easy-agent-core";
+import {} from "@vietor/agent-core";
 const GLYPHS = {
     pending: "○",
-    in_progress: "◐",
+    inProgress: "◐",
     completed: "✓",
 };
 const COLORS = {
     pending: "gray",
-    in_progress: "yellow",
+    inProgress: "yellow",
     completed: "green",
 };
 export const TodoView = memo(function TodoView({ todos }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vietor/easy-agent",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -9,7 +9,7 @@
   "files": [
     "dist"
   ],
-  "description": "Terminal-based AI agent CLI with conversational TUI (Ink/React) powered by easy-agent-core",
+  "description": "Terminal-based AI agent CLI with conversational TUI (Ink/React) powered by agent-core",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
     "react": "^19.2.8",
     "string-width": "^8.2.2",
     "zod": "^4.4.3",
-    "@vietor/easy-agent-core": "0.6.3"
+    "@vietor/agent-core": "0.7.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",