itermbot 1.0.2 → 1.0.4

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "itermbot",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "iTermBot: ReAct agent (LangChain) + DeepAgent (DeepAgents) using @easynet framework",
   "type": "module",
   "main": "dist/index.js",
+  "bin": {
+    "itermbot": "dist/index.js",
+    "iTermBot": "dist/index.js",
+    "iTermbot": "dist/index.js"
+  },
   "scripts": {
+    "preinstall": "node scripts/resolve-deps.js",
     "build": "tsc -p config/tsconfig.json",
     "dev": "tsc -p config/tsconfig.json --watch",
     "start": "node dist/index.js",
@@ -12,32 +18,36 @@
     "deep": "node dist/index.js deep",
     "typecheck": "tsc -p config/tsconfig.json --noEmit",
     "lint": "tsc -p config/tsconfig.json --noEmit",
-    "test": "npm run typecheck",
+    "test": "npm run typecheck && npm run build && npm run test:policy",
+    "test:policy": "npm run build && node --test --test-concurrency=1 test/*.test.mjs",
+    "test:live": "npm run build && node --test --test-concurrency=1 test/live-iterm-llm.integration.test.mjs",
     "test:llm": "node scripts/test-llm.mjs",
     "release": "semantic-release"
   },
   "dependencies": {
     "@easynet/agent-common": "latest",
-    "@easynet/agent-model": "latest",
     "@easynet/agent-memory": "latest",
+    "@easynet/agent-model": "latest",
+    "@easynet/agent-runtime": "latest",
+    "@easynet/agent-skill": "latest",
     "@easynet/agent-tool": "latest",
     "@easynet/agent-tool-buildin": "latest",
-    "@langchain/core": "latest",
-    "@langchain/langgraph": "latest",
-    "@langchain/langgraph-checkpoint": "latest",
-    "deepagents": "latest",
-    "langchain": "latest",
-    "zod": "latest",
-    "@easynet/agent-runtime": "latest"
+    "@langchain/core": "1.1.27",
+    "@langchain/langgraph": "1.1.5",
+    "@langchain/langgraph-checkpoint": "1.0.0",
+    "better-sqlite3": "^12.6.2",
+    "deepagents": "1.8.0",
+    "langchain": "1.2.25",
+    "zod": "latest"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
-    "typescript": "~5.7.2",
     "@semantic-release/commit-analyzer": "^13.0.0",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/npm": "^12.0.0",
     "@semantic-release/release-notes-generator": "^14.0.0",
-    "semantic-release": "^24.2.0"
+    "@types/node": "^22.10.0",
+    "semantic-release": "^24.2.0",
+    "typescript": "~5.7.2"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/internal-package-refs.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const INTERNAL_SCOPE = "@easynet/";
+const DEP_SECTIONS = ["dependencies", "devDependencies", "optionalDependencies"];
+
+function isIgnoredDir(name) {
+  return name === "node_modules" || name === ".git" || name.startsWith(".");
+}
+
+function isInternalPackageName(name) {
+  return typeof name === "string" && name.startsWith(INTERNAL_SCOPE);
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function findRepoRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    const candidate = resolve(current, "agent-runtime");
+    if (existsSync(candidate)) return current;
+    const gitDir = resolve(current, ".git");
+    const packageJson = resolve(current, "package.json");
+    if (existsSync(gitDir) && existsSync(packageJson)) return current;
+    const parent = dirname(current);
+    if (parent === current) {
+      return resolve(startDir);
+    }
+    current = parent;
+  }
+}
+
+export function collectPackageJsonPaths(rootDir) {
+  const out = [];
+  function walk(currentDir) {
+    for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (isIgnoredDir(entry.name)) continue;
+        walk(resolve(currentDir, entry.name));
+        continue;
+      }
+      if (entry.name !== "package.json") continue;
+      const fullPath = resolve(currentDir, entry.name);
+      if (fullPath.includes(`${sep}test${sep}fixtures${sep}`)) continue;
+      out.push(fullPath);
+    }
+  }
+  walk(rootDir);
+  return out.sort();
+}
+
+export function buildInternalPackageMap(repoRoot) {
+  const packageJsonPaths = collectPackageJsonPaths(repoRoot);
+  const map = new Map();
+  for (const pkgPath of packageJsonPaths) {
+    const pkg = readJson(pkgPath);
+    if (!isInternalPackageName(pkg.name)) continue;
+    map.set(pkg.name, {
+      name: pkg.name,
+      version: pkg.version,
+      packageJsonPath: pkgPath,
+      dir: dirname(pkgPath),
+    });
+  }
+  return map;
+}
+
+function normalizeFileRef(fromDir, toDir) {
+  const rel = relative(fromDir, toDir) || ".";
+  return `file:${rel.split(sep).join("/")}`;
+}
+
+function resolvePublishFallbackVersion(name, current) {
+  if (!isInternalPackageName(name)) return current;
+  if (typeof current === "string" && !current.startsWith("file:")) return current;
+  return "latest";
+}
+
+export function syncPackageJsonRefs(pkgPath, options = {}) {
+  const mode = options.mode ?? "auto";
+  const repoRoot = options.repoRoot ?? findRepoRoot(dirname(pkgPath));
+  const internalPackages = options.internalPackages ?? buildInternalPackageMap(repoRoot);
+  const resolvedMode = mode === "auto" ? (process.env.CI ? "publish" : "file") : mode;
+  if (resolvedMode !== "file" && resolvedMode !== "publish") {
+    throw new Error(`Unsupported sync mode: ${resolvedMode}`);
+  }
+
+  const pkg = readJson(pkgPath);
+  let changed = false;
+  const pkgDir = dirname(pkgPath);
+
+  for (const section of DEP_SECTIONS) {
+    const deps = pkg[section];
+    if (!deps || typeof deps !== "object") continue;
+    for (const [name, current] of Object.entries(deps)) {
+      if (!isInternalPackageName(name)) continue;
+      const internal = internalPackages.get(name);
+      const nextValue = internal
+        ? (resolvedMode === "file"
+          ? normalizeFileRef(pkgDir, internal.dir)
+          : internal.version)
+        : (resolvedMode === "publish"
+          ? resolvePublishFallbackVersion(name, current)
+          : current);
+      if (current === nextValue) continue;
+      deps[name] = nextValue;
+      changed = true;
+      console.log(`[internal-package-refs] ${pkg.name} ${section}.${name}: ${current} -> ${nextValue}`);
+    }
+  }
+
+  if (changed) writeJson(pkgPath, pkg);
+  return { changed, mode: resolvedMode, pkgName: pkg.name ?? pkgPath };
+}
+
+export function checkWorkspacePackageRefs(repoRoot) {
+  const internalPackages = buildInternalPackageMap(repoRoot);
+  const failures = [];
+  for (const pkgPath of collectPackageJsonPaths(repoRoot)) {
+    const pkg = readJson(pkgPath);
+    for (const section of DEP_SECTIONS) {
+      const deps = pkg[section];
+      if (!deps || typeof deps !== "object") continue;
+      for (const [name, version] of Object.entries(deps)) {
+        if (!isInternalPackageName(name)) continue;
+        if (typeof version !== "string") continue;
+        if (version === "latest") {
+          failures.push(`${pkg.name}: ${section}.${name} must not use "latest"`);
+          continue;
+        }
+        const internal = internalPackages.get(name);
+        if (!internal) continue;
+        const expectedFile = normalizeFileRef(dirname(pkgPath), internal.dir);
+        if (version.startsWith("file:")) {
+          if (version !== expectedFile) {
+            failures.push(`${pkg.name}: ${section}.${name} should use ${expectedFile}, found ${version}`);
+          }
+        }
+      }
+    }
+  }
+  return failures;
+}
+
+export function syncCurrentPackageFromScript(scriptUrl, mode = "auto") {
+  const scriptDir = dirname(fileURLToPath(scriptUrl));
+  const pkgPath = resolve(scriptDir, "..", "package.json");
+  return syncPackageJsonRefs(pkgPath, { mode });
+}

package/scripts/patch-buildin-cache.sh

@@ -16,10 +16,7 @@ if [ ! -d "$CACHE_DIR/dist" ]; then
   exit 1
 fi
 
-cp "$LOCAL_DIR/dist/src/iterm/itermRunCommandInSession.js" "$CACHE_DIR/dist/src/iterm/"
-cp "$LOCAL_DIR/dist/src/iterm/itermRunCommandInSession.d.ts" "$CACHE_DIR/dist/src/iterm/" 2>/dev/null || true
-cp "$LOCAL_DIR/dist/src/iterm/common.js" "$CACHE_DIR/dist/src/iterm/"
-cp "$LOCAL_DIR/dist/src/iterm/common.d.ts" "$CACHE_DIR/dist/src/iterm/" 2>/dev/null || true
+cp -r "$LOCAL_DIR/dist/src/iterm/" "$CACHE_DIR/dist/src/"
 cp "$LOCAL_DIR/dist/core-tools-manifest.json" "$CACHE_DIR/dist/"
 
 echo "Patched cache at $CACHE_DIR with local build v$VERSION"

package/scripts/resolve-deps.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { syncCurrentPackageFromScript } from "./internal-package-refs.mjs";
+
+syncCurrentPackageFromScript(import.meta.url, "auto");

package/scripts/test-llm.mjs

@@ -1,15 +1,21 @@
 /**
  * Quick LLM config test. Run from app root: npm run test:llm
  */
-import { createAgentLlm } from "@easynet/agent-model";
+import { AgentContextTokens, getDefaultAgentContext } from "@easynet/agent-common/context";
+import { createAgentModel } from "@easynet/agent-model";
+import { loadAppConfig, getModelsConfigPath } from "../dist/config.js";
 
 async function main() {
   try {
-    console.log("[test-llm] Loading LLM from config/models.yaml ...");
-    const llm = await createAgentLlm({
-      configPath: "config/models.yaml",
-      checkConnectivity: false,
+    const appConfig = await loadAppConfig("config/app.yaml");
+    const agentNames = Object.keys(appConfig?.app?.agent ?? {});
+    const agentName = appConfig?.app?.defaultAgent ?? agentNames[0];
+    const modelPath = getModelsConfigPath(appConfig, agentName);
+    console.log(`[test-llm] Loading LLM from ${modelPath} ...`);
+    await createAgentModel({
+      configPath: modelPath,
     });
+    const llm = getDefaultAgentContext().get(AgentContextTokens.ChatModel);
 
     console.log("[test-llm] Invoking LLM ...");
     const res = await llm.invoke(

package/skills/gpu-ssh-monitor/SKILL.md

@@ -16,18 +16,33 @@ Use this skill when the user asks to check remote NVIDIA GPU status on `boqiang@
 - Run all commands in the iTerm target panel via `itermRunCommandInSession`.
 - Do not use local machine commands for data collection.
 - Show exact terminal evidence before summary.
+- Do not run `nvidia-smi` before SSH context is confirmed on `ssh.easynet.world`.
 
 ## Workflow
 
 1. Connect remote host:
    - `ssh boqiang@ssh.easynet.world`
-2. Verify GPU command availability:
+2. Confirm remote context before any GPU command:
+   - `hostname && whoami`
+   - Must show remote host/user evidence consistent with `ssh.easynet.world` / `boqiang`.
+   - If still local shell, stop and ask user to complete SSH login in target panel.
+3. Verify GPU command availability:
    - `nvidia-smi`
-3. Start live monitor:
+   - If output contains `command not found` / `not recognized` / missing driver errors:
+     - Stop monitoring workflow immediately.
+     - Report only failure evidence from terminal output.
+     - Suggest next checks on remote host:
+       - `which nvidia-smi`
+       - `echo $PATH`
+       - `uname -a`
+       - `cat /etc/os-release`
+       - `ls -l /usr/bin/nvidia-smi /usr/local/bin/nvidia-smi 2>/dev/null`
+     - Do not report GPU model/memory/utilization fields when `nvidia-smi` is unavailable.
+4. Start live monitor:
    - Preferred: `watch -n 1 nvidia-smi`
    - Fallback when `watch` is unavailable:
      - `while true; do clear; nvidia-smi; sleep 1; done`
-4. Stop monitor:
+5. Stop monitor:
    - `Ctrl+C`
 
 ## Reporting format
@@ -38,6 +53,10 @@ Use this skill when the user asks to check remote NVIDIA GPU status on `boqiang@
   - Memory usage per GPU
   - GPU utilization and temperature
   - Any obvious anomaly (e.g. 0 MiB but high util, ECC/Xid errors)
+- If `nvidia-smi` failed, summary must only contain:
+  - failure reason from output,
+  - one concrete next command,
+  - no unrelated environment/file observations.
 
 ## Notes
 

package/src/chat/builtin-commands.ts

@@ -0,0 +1,70 @@
+import { AgentContextTokens } from "@easynet/agent-common/context";
+import { normalizeToolList, shortToolName } from "@easynet/agent-common/utils";
+
+type RuntimeLike = {
+  context: {
+    get<T>(token: unknown): T;
+  };
+};
+
+type ToolLike = {
+  name: string;
+  description?: string;
+};
+
+type SkillLike = {
+  name: string;
+  description?: string;
+};
+
+type SkillSetLike = {
+  list: () => SkillLike[];
+};
+
+function isToolLike(tool: unknown): tool is ToolLike {
+  return Boolean(
+    tool
+    && typeof tool === "object"
+    && typeof (tool as { name?: unknown }).name === "string",
+  );
+}
+
+function safeGet<T>(runtime: RuntimeLike, token: unknown): T | null {
+  try {
+    return runtime.context.get<T>(token);
+  } catch {
+    return null;
+  }
+}
+
+function formatTools(runtime: RuntimeLike): string {
+  const raw = safeGet<unknown>(runtime, AgentContextTokens.Tools);
+  const tools = normalizeToolList<ToolLike>(raw, isToolLike);
+  if (tools.length === 0) return "No tools are registered.";
+  const lines = [`Available tools (${tools.length}):`];
+  for (const tool of tools) {
+    const short = shortToolName(tool.name);
+    if (tool.description?.trim()) lines.push(`- ${short}: ${tool.description.trim()}`);
+    else lines.push(`- ${short}`);
+  }
+  return lines.join("\n");
+}
+
+function formatSkills(runtime: RuntimeLike): string {
+  const skillSet = safeGet<SkillSetLike | undefined>(runtime, AgentContextTokens.SkillSet);
+  const skills = skillSet?.list?.() ?? [];
+  if (skills.length === 0) return "No skills are configured.";
+  const lines = [`Available skills (${skills.length}):`];
+  for (const skill of skills) {
+    if (skill.description?.trim()) lines.push(`- ${skill.name}: ${skill.description.trim()}`);
+    else lines.push(`- ${skill.name}`);
+  }
+  return lines.join("\n");
+}
+
+export function tryHandleBuiltinReadCommand(input: string, runtime: RuntimeLike): string | null {
+  const normalized = input.trim().toLowerCase().replace(/\s+/g, " ");
+  if (normalized === "list tools") return formatTools(runtime);
+  if (normalized === "list skills") return formatSkills(runtime);
+  return null;
+}

package/src/chat/progress.ts

@@ -0,0 +1,26 @@
+import { createProgressAgentEventListener, type AgentEventListener } from "@easynet/agent-common/events";
+import { renderStepLine } from "./step-display.js";
+
+function reasonForAction(action: string): string | null {
+  if (action.startsWith("run command:")) {
+    return "Because we need verifiable terminal evidence, execute this command first.";
+  }
+  if (action.startsWith("list directory")) {
+    return "Because we need to confirm directory structure and contents, list the directory first.";
+  }
+  if (action.startsWith("read file:") || action === "read file" || action.startsWith("read path:")) {
+    return "Because conclusions depend on file content, read the file first.";
+  }
+  return null;
+}
+
+export function createChatProgressEventListener(
+  writer: (line: string) => void = console.log,
+): AgentEventListener {
+  return createProgressAgentEventListener({
+    writer: (line: string) => writer(renderStepLine(line)),
+    runLabelReact: "analysis",
+    runLabelDeep: "deep analysis",
+    reasonForAction,
+  });
+}

package/src/chat/response-safety.ts

@@ -0,0 +1,134 @@
+export type ResponseSafetyMode = "off" | "balanced" | "strict";
+export type ResponseSafetyOptions = {
+  evidenceText?: string;
+  targetOs?: string;
+};
+
+function containsDangerousCommand(text: string): boolean {
+  const patterns = [
+    /\brm\s+-rf\b/i,
+    /\bsudo\s+rm\b/i,
+    /\bmkfs(\.| )/i,
+    /\bdd\s+if=/i,
+    /\bdiskutil\s+erase/i,
+  ];
+  return patterns.some((re) => re.test(text));
+}
+
+function redactDangerousCommands(text: string): string {
+  return text
+    .replace(/\brm\s+-rf\b/gi, "[redacted-destructive-command]")
+    .replace(/\bsudo\s+rm\b/gi, "[redacted-destructive-command]")
+    .replace(/\bmkfs(\.| )\S*/gi, "[redacted-destructive-command]")
+    .replace(/\bdd\s+if=\S+/gi, "[redacted-destructive-command]")
+    .replace(/\bdiskutil\s+erase\S*/gi, "[redacted-destructive-command]");
+}
+
+function removeRedactedSuggestionLines(text: string): string {
+  const lines = text
+    .split("\n")
+    .filter((line) => !line.includes("[redacted-destructive-command]"));
+  return lines.join("\n").trim();
+}
+
+function buildGenericSafeGuidance(): string {
+  return [
+    "Safety-preserving workflow:",
+    "1. Start with non-destructive inspection and validation.",
+    "2. Propose reversible actions before irreversible ones.",
+    "3. Ask for explicit confirmation before destructive operations.",
+  ].join("\n");
+}
+
+export function enforceResponseSafety(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed) return trimmed;
+  return enforceResponseSafetyWithMode(trimmed, "balanced");
+}
+
+function extractAbsolutePaths(text: string): string[] {
+  // Restrict path tokens to common path chars so we don't capture markup like "<parameter=...>".
+  const matches = text.match(/(?:^|[^A-Za-z0-9_])((?:\/[A-Za-z0-9._-]+)+)/g) ?? [];
+  const paths = matches
+    .map((raw) => raw.replace(/^[^/]+/, "").trim())
+    .map((p) => p.replace(/[.?!]+$/, ""))
+    .filter((p) => p.startsWith("/") && p.length > 1);
+  return Array.from(new Set(paths));
+}
+
+function hasEvidencePathOverlap(path: string, evidencePaths: Set<string>): boolean {
+  for (const ev of evidencePaths) {
+    if (path === ev) return true;
+    if (path.startsWith(`${ev}/`)) return true;
+    if (ev.startsWith(`${path}/`)) return true;
+  }
+  return false;
+}
+
+function replaceUngroundedPaths(text: string, options?: ResponseSafetyOptions): { text: string; replaced: number } {
+  const evidence = options?.evidenceText?.trim() ?? "";
+  if (!evidence) return { text, replaced: 0 };
+  const responsePaths = extractAbsolutePaths(text);
+  if (responsePaths.length === 0) return { text, replaced: 0 };
+  const evidencePaths = new Set(extractAbsolutePaths(evidence));
+  if (evidencePaths.size === 0) return { text, replaced: 0 };
+
+  let out = text;
+  let replaced = 0;
+  for (const path of responsePaths) {
+    if (hasEvidencePathOverlap(path, evidencePaths)) continue;
+    const escaped = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(escaped, "g");
+    if (re.test(out)) {
+      out = out.replace(re, "(not detected from evidence)");
+      replaced += 1;
+    }
+  }
+
+  // Extra guard for macOS: '/home/*' is usually ungrounded unless explicitly present in evidence.
+  if ((options?.targetOs ?? "").toLowerCase() === "darwin" && !Array.from(evidencePaths).some((p) => p.startsWith("/home/"))) {
+    const homeRe = /\/home\/[A-Za-z0-9._-]+/g;
+    if (homeRe.test(out)) {
+      out = out.replace(homeRe, "(not detected from evidence)");
+      replaced += 1;
+    }
+  }
+  return { text: out, replaced };
+}
+
+export function enforceResponseSafetyWithMode(
+  text: string,
+  mode: ResponseSafetyMode = "balanced",
+  options?: ResponseSafetyOptions,
+): string {
+  const trimmed = text.trim();
+  if (!trimmed) return trimmed;
+  if (mode === "off") return trimmed;
+  const grounded = replaceUngroundedPaths(trimmed, options);
+  if (!containsDangerousCommand(grounded.text)) {
+    if (grounded.replaced === 0) return grounded.text;
+    return `${grounded.text}\n\nSafety note: some paths were replaced because they were not found in tool evidence.`;
+  }
+
+  const redacted = redactDangerousCommands(grounded.text);
+  if (mode === "balanced") {
+    const out = [
+      redacted,
+      "",
+      "Safety note: destructive command suggestions were redacted. Proceed only with explicit confirmation.",
+    ].join("\n");
+    if (grounded.replaced === 0) return out;
+    return `${out}\nSafety note: some paths were replaced because they were not found in tool evidence.`;
+  }
+
+  const cleaned = removeRedactedSuggestionLines(redacted);
+  const safetyNote = [
+    "Safety note: destructive command suggestions were redacted.",
+    "Prefer non-destructive validation first.",
+    "Proceed with destructive operations only after explicit confirmation.",
+  ].join(" ");
+  const body = cleaned.length > 0 ? cleaned : "Potentially destructive suggestions were removed.";
+  const strictOut = `${body}\n\n${buildGenericSafeGuidance()}\n\n${safetyNote}`;
+  if (grounded.replaced === 0) return strictOut;
+  return `${strictOut}\nSafety note: some paths were replaced because they were not found in tool evidence.`;
+}

package/src/chat/step-display.ts

@@ -0,0 +1,54 @@
+function supportsColor(): boolean {
+  return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+
+function colorize(text: string, code: string): string {
+  if (!supportsColor()) return text;
+  return `${code}${text}\x1b[0m`;
+}
+
+function trimStepPrefix(line: string): string {
+  return line.replace(/^ {4}/, "");
+}
+
+export function renderStepLine(line: string): string {
+  if (!line) return "";
+
+  if (line.startsWith("=== Steps: ")) {
+    return colorize(`╭─ ${line.replace(/^===\s*/, "").replace(/\s*===$/, "")}`, "\x1b[1m\x1b[36m");
+  }
+  if (line.startsWith("=== Steps complete: ")) {
+    return colorize(`╰─ ${line.replace(/^===\s*/, "").replace(/\s*===$/, "")}`, "\x1b[1m\x1b[32m");
+  }
+
+  if (/^\[\d{2}\] ▶ /.test(line)) {
+    return colorize(`├─ ${line}`, "\x1b[33m");
+  }
+  if (/^\[\d{2}\] ✓ /.test(line)) {
+    return colorize(`├─ ${line}`, "\x1b[32m");
+  }
+  if (/^\[\d{2}\] ✖ /.test(line)) {
+    return colorize(`├─ ${line}`, "\x1b[31m");
+  }
+
+  if (line.startsWith("    reason: ")) {
+    return colorize(`│  ${trimStepPrefix(line)}`, "\x1b[2m");
+  }
+  if (line.startsWith("    error: ")) {
+    return colorize(`│  ${trimStepPrefix(line)}`, "\x1b[31m");
+  }
+  if (line.startsWith("    progress ")) {
+    return colorize(`│  ${trimStepPrefix(line)}`, "\x1b[34m");
+  }
+  if (line.startsWith("    skill: ")) {
+    return colorize(`│  ${trimStepPrefix(line)}`, "\x1b[35m");
+  }
+  if (line.startsWith("    memory: ")) {
+    return colorize(`│  ${trimStepPrefix(line)}`, "\x1b[2m");
+  }
+  if (line.startsWith("    context: ") || line.startsWith("    planning retry: ")) {
+    return colorize(`│  ${trimStepPrefix(line)}`, "\x1b[2m");
+  }
+
+  return line;
+}

package/src/chat/tool-result.ts

@@ -0,0 +1,22 @@
+import { asRecord } from "@easynet/agent-common/utils";
+
+export function normalizeToolInvokeResult(raw: unknown): unknown {
+  return raw;
+}
+
+export function toolResultOutputText(value: unknown): string | null {
+  const root = asRecord(value);
+  const result = asRecord(root?.result);
+  if (typeof result?.output === "string") return result.output;
+  if (typeof root?.output === "string") return root.output;
+  return null;
+}
+
+export function stringifyToolResult(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}