@athenaintel/react 0.28.0 → 0.30.0

package/dist/tools/tool-summary.js

@@ -0,0 +1,661 @@
+import { hasToolDisplayMeta, getToolDisplayMeta, describeToolArgs, toolCompletedLabel, toolStatusLabel } from "../agent-runtime/src/tool-metadata.js";
+const TARGET_MAX = 72;
+const DETAIL_MAX = 300;
+const EMPTY_TITLES = /* @__PURE__ */ new Map();
+function str(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function int(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) return Number(value.trim());
+  return void 0;
+}
+function clipLine(text, max = TARGET_MAX) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1).trimEnd()}…` : oneLine;
+}
+function capitalize(text) {
+  return text.length > 0 ? `${text[0].toUpperCase()}${text.slice(1)}` : text;
+}
+function lowerFirst(text) {
+  return text.length > 0 ? `${text[0].toLowerCase()}${text.slice(1)}` : text;
+}
+function quoted(text) {
+  return `"${clipLine(text, 60)}"`;
+}
+function plural(count, one, many = `${one}s`) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+function countLines(text) {
+  if (!text) return 0;
+  let lines = 1;
+  for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) {
+    if (index < text.length - 1) lines += 1;
+  }
+  return lines;
+}
+function humanizeToolName(toolName) {
+  const words = toolName.replace(/^mcp__/i, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_\-.:/]+/).filter(Boolean).map((word) => /^[A-Z0-9]{2,}$/.test(word) ? word : word.toLowerCase());
+  return words.length > 0 ? capitalize(words.join(" ")) : toolName;
+}
+function friendlyWorkspacePath(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const path = value.trim();
+  if (path.includes("large_tool_results")) {
+    return "detailed results from an earlier step";
+  }
+  if (path.includes("/memory/")) return "session memory";
+  if (path.includes("/skills/")) return "a skill reference";
+  const base = path.split("/").filter(Boolean).pop();
+  return base ?? path;
+}
+function fileTarget(path) {
+  const friendly = friendlyWorkspacePath(path);
+  if (!friendly || !path) return void 0;
+  const isScratch = friendly !== path.split("/").filter(Boolean).pop();
+  const text = clipLine(friendly, 60);
+  return isScratch ? { text } : { text, code: text };
+}
+function shortPath(path, segments = 2) {
+  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (parts.length === 0) return "/";
+  if (parts.length <= segments) return path.startsWith("/") ? `/${parts.join("/")}` : parts.join("/");
+  return `…/${parts.slice(-segments).join("/")}`;
+}
+function firstCommandLine(command) {
+  const lines = command.split("\n");
+  const firstIndex = lines.findIndex((line) => line.trim().length > 0);
+  if (firstIndex < 0) return { firstLine: "", extraLines: 0 };
+  return {
+    firstLine: lines[firstIndex].trim(),
+    extraLines: Math.max(0, countLines(command) - firstIndex - 1)
+  };
+}
+const EXIT_CODE_NOTE = /^\[Command (?:succeeded|failed) with exit code (-?\d+)\]$/;
+function textOf(result) {
+  if (typeof result === "string") return result;
+  if (Array.isArray(result)) {
+    const texts = result.flatMap((item) => {
+      if (typeof item === "string") return [item];
+      if (item && typeof item === "object" && typeof item.text === "string") {
+        return [item.text];
+      }
+      return [];
+    });
+    return texts.length > 0 ? texts.join("\n") : void 0;
+  }
+  return void 0;
+}
+function executeExitCode(result) {
+  const text = textOf(result);
+  if (!text) return null;
+  const lines = text.trimEnd().split("\n");
+  for (let index = lines.length - 1; index >= 0 && index >= lines.length - 4; index -= 1) {
+    const match = EXIT_CODE_NOTE.exec(lines[index].trim());
+    if (match) return Number.parseInt(match[1], 10);
+  }
+  return null;
+}
+const lineStatsCache = /* @__PURE__ */ new WeakMap();
+function lineMultiset(text) {
+  const counts = /* @__PURE__ */ new Map();
+  if (!text) return counts;
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  for (const line of lines) counts.set(line, (counts.get(line) ?? 0) + 1);
+  return counts;
+}
+function editLineStats(args) {
+  const cached = lineStatsCache.get(args);
+  if (cached) return cached;
+  const before = lineMultiset(typeof args.old_string === "string" ? args.old_string : "");
+  const after = lineMultiset(typeof args.new_string === "string" ? args.new_string : "");
+  let added = 0;
+  let removed = 0;
+  for (const [line, count] of after) added += Math.max(0, count - (before.get(line) ?? 0));
+  for (const [line, count] of before) removed += Math.max(0, count - (after.get(line) ?? 0));
+  const stats = { added, removed };
+  lineStatsCache.set(args, stats);
+  return stats;
+}
+const MAX_PARSE_LENGTH = 256 * 1024;
+function parseResult(result) {
+  if (result && typeof result === "object") return result;
+  if (typeof result !== "string" || result.length > MAX_PARSE_LENGTH) return null;
+  const trimmed = result.trimStart();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function resultRecord(result) {
+  const parsed = parseResult(result);
+  return parsed && !Array.isArray(parsed) ? parsed : null;
+}
+function resultNumber(result) {
+  const record = resultRecord(result);
+  if (!record) return void 0;
+  const direct = int(record.number) ?? int(record.pull_number) ?? int(record.issue_number);
+  if (direct !== void 0) return direct;
+  const url = str(record.html_url) ?? str(record.url);
+  const match = url ? /\/(?:pull|issues)\/(\d+)/.exec(url) : null;
+  return match ? Number(match[1]) : void 0;
+}
+const ASSET_ID = /^asset_[A-Za-z0-9-]{6,}$/;
+const MAX_WALK_NODES = 2e3;
+const titlesByResultObject = /* @__PURE__ */ new WeakMap();
+const titlesByStringPart = /* @__PURE__ */ new WeakMap();
+function titlesIn(value) {
+  const found = [];
+  const stack = [{ node: value, depth: 0 }];
+  let visited = 0;
+  while (stack.length > 0 && visited < MAX_WALK_NODES) {
+    const { node, depth } = stack.pop();
+    visited += 1;
+    if (!node || typeof node !== "object" || depth > 4) continue;
+    if (Array.isArray(node)) {
+      for (const child of node) stack.push({ node: child, depth: depth + 1 });
+      continue;
+    }
+    const record = node;
+    const id = str(record.asset_id) ?? str(record.id) ?? str(record.assetId);
+    const title = str(record.title) ?? str(record.name);
+    if (id && title && ASSET_ID.test(id)) found.push([id, title]);
+    for (const child of Object.values(record)) {
+      if (child && typeof child === "object") stack.push({ node: child, depth: depth + 1 });
+    }
+  }
+  return found;
+}
+function resultTitles(part) {
+  const result = part.result;
+  if (result !== null && typeof result === "object") {
+    let entries2 = titlesByResultObject.get(result);
+    if (!entries2) {
+      entries2 = titlesIn(result);
+      titlesByResultObject.set(result, entries2);
+    }
+    return entries2;
+  }
+  if (typeof result !== "string") return [];
+  const cached = titlesByStringPart.get(part);
+  if (cached && cached.result === result) return cached.entries;
+  const entries = titlesIn(parseResult(result));
+  titlesByStringPart.set(part, { result, entries });
+  return entries;
+}
+function collectAssetTitles(parts) {
+  const titles = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    if (part.type !== "tool-call" || part.result === void 0) continue;
+    for (const [id, title] of resultTitles(part)) titles.set(id, title);
+  }
+  return titles;
+}
+function assetIdOf(value) {
+  const raw = str(value);
+  if (!raw) return void 0;
+  const bare = raw.split(/[?#]/, 1)[0];
+  return bare.startsWith("asset_") ? bare : void 0;
+}
+const RUN = ["Running", "Ran", "run"];
+const READ = ["Reading", "Read", "read"];
+function summaryFromPhrase(phrase, status) {
+  const [active, done, base] = phrase.verb;
+  const imperative = `${capitalize(base)} ${phrase.object}`;
+  let label;
+  switch (status) {
+    case "running":
+      label = phrase.active ?? `${active} ${phrase.object}`;
+      break;
+    case "complete":
+      label = phrase.done ?? `${done} ${phrase.object}`;
+      break;
+    case "error":
+      label = `Couldn't ${base} ${phrase.object}`;
+      break;
+    case "rejected":
+      label = `${imperative} — rejected`;
+      break;
+    case "cancelled":
+      label = `${imperative} — cancelled`;
+      break;
+    case "paused":
+      label = `${imperative} — paused`;
+      break;
+    case "waiting":
+      label = "Waiting for your input";
+      break;
+  }
+  const meta = (phrase.meta ?? []).filter((value) => Boolean(value)).join(" · ");
+  const detail = status === "waiting" ? imperative : phrase.detail;
+  return {
+    label,
+    ...phrase.code && label.includes(phrase.code) ? { code: phrase.code } : {},
+    ...detail ? { detail: clipLine(detail, DETAIL_MAX) } : {},
+    ...meta ? { meta } : {}
+  };
+}
+function machineName(titles, value) {
+  const id = assetIdOf(value);
+  return id ? titles.get(id) : void 0;
+}
+function onMachine(titles, args) {
+  const machine = machineName(titles, args.sandbox_asset_id);
+  return machine ? `on ${machine}` : void 0;
+}
+const COMPUTER_STATES = {
+  started: "running",
+  running: "running",
+  stopped: "stopped",
+  starting: "starting",
+  stopping: "stopping",
+  paused: "paused",
+  error: "in an error state"
+};
+function computerStateWord(state) {
+  return COMPUTER_STATES[state.toLowerCase()] ?? humanizeToolName(state).toLowerCase();
+}
+const executeRule = ({ args, result, titles }) => {
+  const command = typeof args.command === "string" ? args.command : "";
+  const { firstLine, extraLines } = firstCommandLine(command);
+  const target = firstLine ? clipLine(firstLine) : void 0;
+  const exitCode = executeExitCode(result);
+  return {
+    verb: RUN,
+    object: target ?? "a command",
+    code: target,
+    detail: firstLine ? extraLines > 0 ? `${firstLine} (+${plural(extraLines, "more line")})` : firstLine : void 0,
+    meta: [onMachine(titles, args), exitCode !== null && exitCode !== 0 && `exit ${exitCode}`]
+  };
+};
+function filePathOf(args) {
+  return str(args.file_path) ?? str(args.path);
+}
+const readFileRule = ({ args, titles }) => {
+  const path = filePathOf(args);
+  const target = fileTarget(path);
+  const offset = int(args.offset) ?? 0;
+  const limit = int(args.limit);
+  return {
+    verb: READ,
+    object: (target == null ? void 0 : target.text) ?? "a file",
+    code: target == null ? void 0 : target.code,
+    detail: path,
+    meta: [
+      offset > 0 && (limit ? `lines ${offset + 1}–${offset + limit}` : `from line ${offset + 1}`),
+      onMachine(titles, args)
+    ]
+  };
+};
+const listRule = ({ args, titles }) => {
+  const path = str(args.path) ?? str(args.file_path);
+  const target = path ? shortPath(path) : void 0;
+  return {
+    verb: ["Listing", "Listed", "list"],
+    object: target ?? "the workspace",
+    code: target,
+    detail: path,
+    meta: [onMachine(titles, args)]
+  };
+};
+const globRule = ({ args, result, titles }) => {
+  const pattern = str(args.pattern) ?? str(args.query);
+  const path = str(args.path);
+  const object = pattern ? `files matching ${clipLine(pattern, 60)}` : "files";
+  const none = typeof result === "string" && /^no files found/i.test(result.trim());
+  return {
+    verb: ["Finding", "Found", "find"],
+    object,
+    code: pattern ? clipLine(pattern, 60) : void 0,
+    done: none && pattern ? `No files match ${clipLine(pattern, 60)}` : void 0,
+    detail: path ? `${pattern ?? ""} in ${path}`.trim() : pattern,
+    meta: [path && `in ${shortPath(path)}`, onMachine(titles, args)]
+  };
+};
+const grepRule = ({ args, result, titles }) => {
+  const pattern = str(args.pattern) ?? str(args.query);
+  const path = str(args.path);
+  const code = pattern ? clipLine(pattern, 60) : void 0;
+  const where = path ? `${shortPath(path)} ` : "";
+  const object = code ? `${where}for ${code}` : path ? shortPath(path) : "files";
+  const none = typeof result === "string" && (result.trim() === "" || /^no matches/i.test(result.trim()));
+  return {
+    verb: ["Searching", "Searched", "search"],
+    object,
+    code,
+    done: none && code ? `No matches for ${code}${path ? ` in ${shortPath(path)}` : ""}` : void 0,
+    detail: path ? `${pattern ?? ""} in ${path}`.trim() : pattern,
+    meta: [str(args.glob), onMachine(titles, args)]
+  };
+};
+const writeFileRule = ({ args, titles }) => {
+  const path = filePathOf(args);
+  const target = fileTarget(path);
+  const content = typeof args.content === "string" ? args.content : "";
+  const lines = countLines(content);
+  return {
+    verb: ["Writing", "Wrote", "write"],
+    object: (target == null ? void 0 : target.text) ?? "a file",
+    code: target == null ? void 0 : target.code,
+    detail: path,
+    meta: [lines > 0 && `+${lines}`, onMachine(titles, args)]
+  };
+};
+const editFileRule = ({ args, titles }) => {
+  const path = filePathOf(args);
+  const target = fileTarget(path);
+  const hasReplacement = typeof args.old_string === "string" || typeof args.new_string === "string";
+  const { added, removed } = hasReplacement ? editLineStats(args) : { added: 0, removed: 0 };
+  return {
+    verb: ["Editing", "Edited", "edit"],
+    object: (target == null ? void 0 : target.text) ?? "a file",
+    code: target == null ? void 0 : target.code,
+    detail: path,
+    meta: [
+      added + removed > 0 && `+${added} −${removed}`,
+      args.replace_all === true && "all occurrences",
+      onMachine(titles, args)
+    ]
+  };
+};
+const searchAssetsRule = ({ args, result }) => {
+  const query = str(args.title_contains_keyword) ?? str(args.query) ?? str(args.search_query) ?? str(args.keyword);
+  const types = Array.isArray(args.types) ? args.types.map(str).filter((type) => type !== void 0) : [];
+  const record = resultRecord(result);
+  const assets = Array.isArray(record == null ? void 0 : record.assets) ? record.assets : void 0;
+  const count = int(record == null ? void 0 : record.total_count) ?? int(record == null ? void 0 : record.returned_count) ?? (assets == null ? void 0 : assets.length);
+  const forQuery = query ? ` for ${quoted(query)}` : "";
+  const done = count === void 0 ? void 0 : count === 0 ? `No assets found${forQuery}` : `Found ${plural(count, "asset")}${forQuery}`;
+  return {
+    verb: ["Searching", "Searched", "search"],
+    object: query ? `for ${quoted(query)}` : "assets",
+    done,
+    meta: [types.length > 0 && types.map((type) => humanizeToolName(type).toLowerCase()).join(", ")]
+  };
+};
+const ensureSandboxRule = ({ args, result, titles }) => {
+  const machine = machineName(titles, args.computer_asset_id ?? args.asset_id);
+  const record = resultRecord(result);
+  const state = str(record == null ? void 0 : record.state);
+  return {
+    verb: ["Starting", "Started", "start"],
+    object: machine ?? "the computer",
+    done: state ? `${machine ?? "The computer"} is ${computerStateWord(state)}` : void 0,
+    detail: str(record == null ? void 0 : record.detail)
+  };
+};
+const computerStatusRule = ({ args, result, titles }) => {
+  var _a;
+  const machine = machineName(titles, args.computer_asset_id ?? args.asset_id);
+  const state = str((_a = resultRecord(result)) == null ? void 0 : _a.state);
+  return {
+    verb: ["Checking", "Checked", "check"],
+    object: machine ?? "the computer",
+    done: state ? `${machine ?? "The computer"} is ${computerStateWord(state)}` : void 0
+  };
+};
+const computerDeployRule = ({ args, result, titles }) => {
+  var _a;
+  const machine = machineName(titles, args.computer_asset_id ?? args.asset_id);
+  const port = int(args.port);
+  const url = str((_a = resultRecord(result)) == null ? void 0 : _a.url);
+  return {
+    verb: ["Deploying", "Deployed", "deploy"],
+    object: port !== void 0 ? `port ${port}` : machine ?? "the computer",
+    detail: url,
+    meta: [port !== void 0 && machine && `on ${machine}`]
+  };
+};
+const computerCreateRule = ({ args }) => {
+  const name = str(args.name) ?? str(args.title);
+  return {
+    verb: ["Creating", "Created", "create"],
+    object: name ? `computer ${quoted(name)}` : "a computer"
+  };
+};
+function repoOf(args) {
+  const owner = str(args.owner);
+  const repo = str(args.repo);
+  if (owner && repo) return `${owner}/${repo}`;
+  return repo ?? str(args.repository);
+}
+const githubPullRule = ({ args }) => {
+  const number = int(args.pull_number) ?? int(args.number);
+  const repo = repoOf(args);
+  return {
+    verb: ["Viewing", "Viewed", "view"],
+    object: number !== void 0 ? `pull request #${number}` : "a pull request",
+    detail: repo && number !== void 0 ? `${repo}#${number}` : repo,
+    meta: [repo]
+  };
+};
+const githubListPullsRule = ({ args }) => {
+  const repo = repoOf(args);
+  const state = str(args.state);
+  return {
+    verb: ["Listing", "Listed", "list"],
+    object: state && state !== "open" ? `${state} pull requests` : "pull requests",
+    meta: [repo, str(args.head) && `head ${str(args.head)}`]
+  };
+};
+const githubOpenPullRule = ({ args, result }) => {
+  const title = str(args.title);
+  const number = resultNumber(result);
+  const head = str(args.head);
+  const base = str(args.base);
+  return {
+    verb: ["Opening", "Opened", "open"],
+    object: title ? `pull request ${quoted(title)}` : "a pull request",
+    done: number !== void 0 ? `Opened pull request #${number}` : void 0,
+    detail: title,
+    meta: [head && base && `${head} → ${base}`, args.draft === true && "draft", repoOf(args)]
+  };
+};
+const githubCommentRule = ({ args }) => {
+  const number = int(args.issue_number) ?? int(args.pull_number);
+  return {
+    verb: ["Commenting on", "Commented on", "comment on"],
+    object: number !== void 0 ? `#${number}` : "an issue",
+    meta: [repoOf(args)]
+  };
+};
+const githubIssueRule = ({ args, result }) => {
+  const title = str(args.title);
+  const number = resultNumber(result);
+  return {
+    verb: ["Creating", "Created", "create"],
+    object: title ? `issue ${quoted(title)}` : "an issue",
+    done: number !== void 0 ? `Created issue #${number}` : void 0,
+    detail: title,
+    meta: [repoOf(args)]
+  };
+};
+const githubFileRule = ({ args }) => {
+  const path = str(args.path);
+  const target = fileTarget(path);
+  const repo = repoOf(args);
+  return {
+    verb: READ,
+    object: (target == null ? void 0 : target.text) ?? "a file",
+    code: target == null ? void 0 : target.code,
+    detail: repo && path ? `${repo}/${path}` : path,
+    meta: [repo, str(args.ref)]
+  };
+};
+const githubDirectoryRule = ({ args }) => {
+  const path = str(args.path);
+  return {
+    verb: ["Listing", "Listed", "list"],
+    object: path ? shortPath(path) : "the repository root",
+    code: path ? shortPath(path) : void 0,
+    meta: [repoOf(args)]
+  };
+};
+const webSearchRule = ({ args }) => {
+  const query = str(args.query) ?? str(args.search_query) ?? str(args.term);
+  return {
+    verb: ["Searching", "Searched", "search"],
+    object: query ? `the web for ${quoted(query)}` : "the web"
+  };
+};
+function pageLabel(value) {
+  const raw = str(value);
+  if (!raw) return void 0;
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    const path = url.pathname === "/" ? "" : url.pathname;
+    return clipLine(`${url.hostname.replace(/^www\./, "")}${path}`, 60);
+  } catch {
+    return void 0;
+  }
+}
+const browseRule = ({ args }) => {
+  const page = pageLabel(args.url) ?? pageLabel(args.link);
+  return { verb: READ, object: page ?? "a web page" };
+};
+const readAssetRule = ({ args, titles }) => {
+  const rawIds = Array.isArray(args.asset_ids) ? args.asset_ids : [args.asset_id ?? args.asset_ids];
+  const ids = rawIds.map(assetIdOf).filter((id) => id !== void 0);
+  const named = ids.map((id) => titles.get(id)).filter((title) => Boolean(title));
+  const object = ids.length > 1 ? plural(ids.length, "asset") : named[0] ? clipLine(named[0], 60) : "an asset";
+  return {
+    verb: READ,
+    object,
+    detail: ids.length > 1 && named.length > 0 ? named.join(", ") : void 0
+  };
+};
+const writeTodosRule = ({ args }) => {
+  const todos = Array.isArray(args.todos) ? args.todos : [];
+  const done = todos.filter((todo) => (todo == null ? void 0 : todo.status) === "completed").length;
+  const current = todos.find((todo) => (todo == null ? void 0 : todo.status) === "in_progress");
+  return {
+    verb: ["Updating", "Updated", "update"],
+    object: "plan",
+    done: todos.length === 0 ? "Cleared the plan" : `Updated plan (${done}/${todos.length} done)`,
+    detail: str(current == null ? void 0 : current.content) ? `Now: ${str(current == null ? void 0 : current.content)}` : void 0
+  };
+};
+function subagentName(value) {
+  const name = str(value);
+  if (!name || name === "general-purpose") return "a subagent";
+  return humanizeToolName(name).toLowerCase();
+}
+const taskRule = ({ args }) => {
+  const description = str(args.description);
+  const who = subagentName(args.subagent_type);
+  return {
+    verb: ["Delegating to", "Delegated to", "delegate to"],
+    object: description ? `${who}: ${clipLine(description, 64)}` : who,
+    detail: description
+  };
+};
+const startAsyncTaskRule = ({ args }) => {
+  const description = str(args.description);
+  return {
+    verb: ["Starting", "Started", "start"],
+    object: description ? `background task: ${clipLine(description, 56)}` : "a background task",
+    detail: description
+  };
+};
+const RULES = {
+  execute: executeRule,
+  read_file: readFileRule,
+  ls: listRule,
+  glob: globRule,
+  grep: grepRule,
+  write_file: writeFileRule,
+  edit_file: editFileRule,
+  search_assets: searchAssetsRule,
+  computer_asset_ensure_sandbox: ensureSandboxRule,
+  computer_asset_get_status: computerStatusRule,
+  computer_asset_deploy: computerDeployRule,
+  computer_asset_create: computerCreateRule,
+  github_get_pull_request: githubPullRule,
+  github_list_pull_requests: githubListPullsRule,
+  github_open_pull_request: githubOpenPullRule,
+  github_comment: githubCommentRule,
+  github_create_issue: githubIssueRule,
+  github_fetch_file: githubFileRule,
+  github_list_directory: githubDirectoryRule,
+  search: webSearchRule,
+  web_search: webSearchRule,
+  search_web: webSearchRule,
+  exa_search: webSearchRule,
+  perplexity_search: webSearchRule,
+  firecrawl_search: webSearchRule,
+  browse: browseRule,
+  web_fetch: browseRule,
+  fetch_url: browseRule,
+  web_scrape: browseRule,
+  scrape_web: browseRule,
+  firecrawl_scrape: browseRule,
+  read_asset: readAssetRule,
+  write_todos: writeTodosRule,
+  task: taskRule,
+  start_async_task: startAsyncTaskRule
+};
+function registrySummary(toolName, args, status) {
+  const meta = getToolDisplayMeta(toolName);
+  const described = describeToolArgs({ toolName, args });
+  const label = status === "running" ? meta.activeLabel : status === "complete" ? meta.completedLabel ?? toolCompletedLabel(meta.activeLabel) : toolStatusLabel(toolName, status);
+  return {
+    label,
+    ...described && status !== "waiting" ? { meta: clipLine(described, 60) } : {}
+  };
+}
+function unknownToolSummary(toolName, status, displayName) {
+  const name = displayName ?? humanizeToolName(toolName);
+  const inSentence = displayName ?? lowerFirst(name);
+  switch (status) {
+    case "running":
+      return { label: `Running ${inSentence}` };
+    case "complete":
+      return { label: displayName ?? `Ran ${inSentence}` };
+    case "error":
+      return { label: `${name} failed` };
+    case "rejected":
+      return { label: `${name} — rejected` };
+    case "cancelled":
+      return { label: `${name} — cancelled` };
+    case "paused":
+      return { label: `${name} — paused` };
+    case "waiting":
+      return { label: "Waiting for your input", detail: name };
+  }
+}
+function summarizeToolCall({
+  toolName,
+  args,
+  result,
+  status,
+  assetTitles,
+  displayName
+}) {
+  const rule = RULES[toolName];
+  if (rule) {
+    return summaryFromPhrase(
+      rule({ args: args ?? {}, result, status, titles: assetTitles ?? EMPTY_TITLES }),
+      status
+    );
+  }
+  if (hasToolDisplayMeta(toolName)) return registrySummary(toolName, args, status);
+  return unknownToolSummary(toolName, status, displayName);
+}
+export {
+  clipLine,
+  collectAssetTitles,
+  countLines,
+  editLineStats,
+  executeExitCode,
+  firstCommandLine,
+  friendlyWorkspacePath,
+  humanizeToolName,
+  shortPath,
+  summarizeToolCall
+};
+//# sourceMappingURL=tool-summary.js.map