@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/web-ui/app/lib/task-progress.js

@@ -0,0 +1,233 @@
+import {
+  getPlanItemPayload,
+  getPlanPayload,
+  getRecord,
+} from "./event-presentation.js";
+import { textOf } from "./text-format.js";
+
+const PLAN_ITEM_STATUSES = new Set([
+  "pending",
+  "in_progress",
+  "done",
+  "blocked",
+]);
+
+export function taskStatusClass(status) {
+  const normalized = textOf(status).trim().toLowerCase();
+  if (normalized === "done" || normalized === "completed") return "done";
+  if (normalized === "in_progress" || normalized === "active") return "active";
+  if (normalized === "blocked" || normalized === "failed") return "failed";
+  if (normalized === "superseded") return "muted";
+  return "pending";
+}
+
+function isTaskProgressCount(value) {
+  return Number.isInteger(value) && value >= 0;
+}
+
+function hasValidPlanItem(item) {
+  if (!getRecord(item)) return false;
+  if (typeof item.title !== "string" || !item.title.trim()) return false;
+  return PLAN_ITEM_STATUSES.has(item.status);
+}
+
+function hasValidPlanSnapshot(plan) {
+  if (!Array.isArray(plan.items)) return false;
+  if (!plan.items.every(hasValidPlanItem)) return false;
+  if (plan.total !== undefined && !isTaskProgressCount(plan.total))
+    return false;
+  if (plan.completed !== undefined && !isTaskProgressCount(plan.completed)) {
+    return false;
+  }
+  const total = plan.total ?? plan.items.length;
+  if (total < plan.items.length) return false;
+  return (plan.completed ?? 0) <= total;
+}
+
+function isPlanEventForRequest(current, message) {
+  if (message.type !== "event") return false;
+  if (typeof message.requestId !== "string" || !message.requestId.trim()) {
+    return false;
+  }
+  if (current && current.requestId !== message.requestId) return false;
+  if (message.stage === "development_plan") return true;
+  return textOf(message.name).startsWith("planner.plan.");
+}
+
+function planEventPosition(message) {
+  if (isTaskProgressCount(message.eventSequence)) {
+    return { source: "eventSequence", value: message.eventSequence };
+  }
+  if (isTaskProgressCount(message.seqNo)) {
+    return { source: "seqNo", value: message.seqNo };
+  }
+  return undefined;
+}
+
+function comparePlanEventPositions(left, right) {
+  if (!left || !right) return undefined;
+  if (left.source !== right.source) return undefined;
+  return left.value - right.value;
+}
+
+function isCoveredPlanEvent(position, baseline) {
+  const comparison = comparePlanEventPositions(position, baseline);
+  return comparison !== undefined && comparison <= 0;
+}
+
+function isLaterPlanEvent(position, baseline) {
+  const comparison = comparePlanEventPositions(position, baseline);
+  return comparison !== undefined && comparison > 0;
+}
+
+function planEventSequence(current, message) {
+  if (isTaskProgressCount(message.eventSequence)) {
+    return {
+      lastEventSequence: Math.max(
+        current?.lastEventSequence ?? 0,
+        message.eventSequence,
+      ),
+      lastSeqNo: current?.lastSeqNo,
+    };
+  }
+  return {
+    lastEventSequence: current?.lastEventSequence,
+    lastSeqNo: isTaskProgressCount(message.seqNo)
+      ? Math.max(current?.lastSeqNo ?? 0, message.seqNo)
+      : current?.lastSeqNo,
+  };
+}
+
+function orderPlanItems(items) {
+  return [...items].sort((left, right) => {
+    const leftOrder = left.order > 0 ? left.order : Infinity;
+    const rightOrder = right.order > 0 ? right.order : Infinity;
+    return leftOrder - rightOrder;
+  });
+}
+
+function findPlanItemIndex(items, nextItem) {
+  const nextId = nextItem.id.trim();
+  if (nextId) {
+    const idIndex = items.findIndex((item) => item.id.trim() === nextId);
+    if (idIndex >= 0) return idIndex;
+  }
+  const nextTitle = nextItem.title.trim().toLowerCase();
+  return items.findIndex((item) => {
+    if (nextId && item.id.trim()) return false;
+    return item.title.trim().toLowerCase() === nextTitle;
+  });
+}
+
+function projectPlanItemUpdate(current, message) {
+  if (!hasValidPlanItem(message.item)) return null;
+  const item = getPlanItemPayload(message);
+  const items = [...(current?.items || [])];
+  const index = findPlanItemIndex(items, item);
+  const previousItem = items[index];
+  const nextItem = {
+    ...item,
+    id: item.id || previousItem?.id || "",
+    order: item.order || previousItem?.order || 0,
+  };
+  if (index < 0) items.push(nextItem);
+  else items[index] = nextItem;
+
+  const total = isTaskProgressCount(message.planTotal)
+    ? message.planTotal
+    : Math.max(current?.total || 0, items.length);
+  const statusChange =
+    Number(nextItem.status === "done") -
+    Number(previousItem?.status === "done");
+  const completed = isTaskProgressCount(message.planCompleted)
+    ? message.planCompleted
+    : Math.max(0, (current?.completed || 0) + statusChange);
+  return {
+    summary: textOf(message.planSummary, current?.summary || ""),
+    total,
+    completed,
+    items,
+    hasSnapshot: current?.hasSnapshot || false,
+  };
+}
+
+function normalizedPlanItemUpdate(message, position) {
+  return {
+    item: getPlanItemPayload(message),
+    position,
+    ...(typeof message.planSummary === "string"
+      ? { planSummary: message.planSummary }
+      : {}),
+    ...(isTaskProgressCount(message.planTotal)
+      ? { planTotal: message.planTotal }
+      : {}),
+    ...(isTaskProgressCount(message.planCompleted)
+      ? { planCompleted: message.planCompleted }
+      : {}),
+  };
+}
+
+function orderPlanItemUpdates(updates) {
+  return [...updates].sort(
+    (left, right) =>
+      comparePlanEventPositions(left.position, right.position) ?? 0,
+  );
+}
+
+function hasRetainedPlanEvent(updates, position) {
+  return updates.some(
+    (update) => comparePlanEventPositions(update.position, position) === 0,
+  );
+}
+
+function reducePlanReplayState(current, message, rawPlan) {
+  const replay = current?.replayState || { itemUpdates: [] };
+  const position = planEventPosition(message);
+  if (isCoveredPlanEvent(position, replay.snapshotPosition)) return null;
+  if (rawPlan) {
+    return {
+      snapshot: { ...getPlanPayload(message), hasSnapshot: true },
+      snapshotPosition: position,
+      itemUpdates: replay.itemUpdates.filter((update) =>
+        isLaterPlanEvent(update.position, position),
+      ),
+    };
+  }
+  if (!hasValidPlanItem(message.item)) return null;
+  if (hasRetainedPlanEvent(replay.itemUpdates, position)) return null;
+  const update = normalizedPlanItemUpdate(message, position);
+  // Intermediate item states matter when legacy deltas omit plan counters.
+  // Keep normalized deltas only until an authoritative snapshot covers them.
+  return {
+    ...replay,
+    itemUpdates: orderPlanItemUpdates([...replay.itemUpdates, update]),
+  };
+}
+
+function projectPlanReplayState(replay) {
+  let projection = replay.snapshot;
+  for (const update of replay.itemUpdates) {
+    projection = projectPlanItemUpdate(projection, update);
+  }
+  return projection;
+}
+
+export function reduceTaskProgress(current, message) {
+  if (!isPlanEventForRequest(current, message)) return current;
+  const rawPlan = getRecord(message.plan);
+  if (rawPlan && !hasValidPlanSnapshot(rawPlan)) return current;
+  const replayState = reducePlanReplayState(current, message, rawPlan);
+  if (!replayState) return current;
+  const projection = projectPlanReplayState(replayState);
+  const items = orderPlanItems(projection.items);
+  return {
+    ...projection,
+    requestId: message.requestId,
+    items,
+    activeItem:
+      items.find((item) => item.status === "in_progress")?.title || "",
+    hasSignal: true,
+    ...planEventSequence(current, message),
+    replayState,
+  };
+}

package/dist/src/web-ui/app/lib/text-format.js

@@ -52,146 +52,5 @@ export function escapeAttribute(value) {
   return escapeHtml(value).replaceAll("'", "'");
 }
 
-export function safeLinkHref(value, baseHref = globalThis.location?.href) {
-  try {
-    const url = new URL(value, baseHref);
-    if (
-      url.protocol === "http:" ||
-      url.protocol === "https:" ||
-      url.protocol === "mailto:"
-    ) {
-      return url.href;
-    }
-  } catch {
-    return "";
-  }
-  return "";
-}
-
-function renderInlineMarkdown(raw) {
-  let text = escapeHtml(raw);
-  const codeTokens = [];
-  text = text.replace(/`([^`]+)`/g, (_, code) => {
-    const token = `@@CODE${codeTokens.length}@@`;
-    codeTokens.push(`<code>${code}</code>`);
-    return token;
-  });
-  text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, href) => {
-    const safeHref = safeLinkHref(href);
-    if (!safeHref) return label;
-    return `<a href="${escapeAttribute(safeHref)}" target="_blank" rel="noreferrer">${label}</a>`;
-  });
-  text = text.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
-  text = text.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>");
-  text = text.replace(/~~([^~]+)~~/g, "<del>$1</del>");
-  for (let index = 0; index < codeTokens.length; index += 1) {
-    text = text.replaceAll(`@@CODE${index}@@`, codeTokens[index]);
-  }
-  return text;
-}
-
-export function renderMarkdown(raw) {
-  const source = textOf(raw);
-  if (!source.trim()) return "";
-  const lines = source.replace(/\r\n/g, "\n").split("\n");
-  const blocks = [];
-  let paragraph = [];
-  let list = [];
-  let quote = [];
-  let code = [];
-  let inCode = false;
-
-  function flushParagraph() {
-    if (paragraph.length === 0) return;
-    blocks.push(
-      `<p>${paragraph.map((line) => renderInlineMarkdown(line)).join("<br>")}</p>`,
-    );
-    paragraph = [];
-  }
-
-  function flushList() {
-    if (list.length === 0) return;
-    blocks.push(
-      `<ul>${list
-        .map((item) => `<li>${renderInlineMarkdown(item)}</li>`)
-        .join("")}</ul>`,
-    );
-    list = [];
-  }
-
-  function flushQuote() {
-    if (quote.length === 0) return;
-    blocks.push(
-      `<blockquote>${quote
-        .map((line) => renderInlineMarkdown(line))
-        .join("<br>")}</blockquote>`,
-    );
-    quote = [];
-  }
-
-  function flushCode() {
-    if (code.length === 0) return;
-    blocks.push(`<pre><code>${escapeHtml(code.join("\n"))}</code></pre>`);
-    code = [];
-  }
-
-  for (const line of lines) {
-    if (line.trim().startsWith("```")) {
-      if (inCode) {
-        flushCode();
-        inCode = false;
-      } else {
-        flushParagraph();
-        flushList();
-        flushQuote();
-        inCode = true;
-      }
-      continue;
-    }
-    if (inCode) {
-      code.push(line);
-      continue;
-    }
-
-    const heading = line.match(/^(#{1,3})\s+(.+)$/);
-    const bullet = line.match(/^\s*[-*]\s+(.+)$/);
-    const numbered = line.match(/^\s*\d+[.]\s+(.+)$/);
-    const quoted = line.match(/^>\s?(.+)$/);
-
-    if (!line.trim()) {
-      flushParagraph();
-      flushList();
-      flushQuote();
-      continue;
-    }
-    if (heading) {
-      flushParagraph();
-      flushList();
-      flushQuote();
-      const level = heading[1].length + 2;
-      blocks.push(`<h${level}>${renderInlineMarkdown(heading[2])}</h${level}>`);
-      continue;
-    }
-    if (bullet || numbered) {
-      flushParagraph();
-      flushQuote();
-      list.push((bullet || numbered)[1]);
-      continue;
-    }
-    if (quoted) {
-      flushParagraph();
-      flushList();
-      quote.push(quoted[1]);
-      continue;
-    }
-    flushList();
-    flushQuote();
-    paragraph.push(line);
-  }
-
-  flushParagraph();
-  flushList();
-  flushQuote();
-  flushCode();
-  return blocks.join("");
-}
+export { safeLinkHref } from "./message-url-policy.js";
+export { renderMarkdown } from "./message-markdown.js";

package/dist/src/web-ui/app/lib/tool-activity-event.d.ts

@@ -0,0 +1,26 @@
+import type { ToolActivityField } from "./tool-activity-model.js";
+
+export interface ToolActivityEvent {
+  name: string;
+  tool: string;
+  executionId: string;
+  executorRole: string;
+  roleCallId: string;
+  payloadStage?: number;
+  payloadStageCount?: number;
+  beforeExternalExecution: boolean;
+  intent: string;
+  target: string;
+  sent: ToolActivityField[];
+  received: ToolActivityField[];
+  preview: string;
+  previewTruncated: boolean;
+  partial: boolean;
+  outcome: "unchanged" | "empty" | "completed";
+  ok: boolean | null;
+  error: string;
+}
+
+export declare function projectToolActivityEvent(
+  message: Record<string, unknown>,
+): ToolActivityEvent | null;

package/dist/src/web-ui/app/lib/tool-activity-event.js

@@ -0,0 +1,228 @@
+import { getRecord, titleCaseEventValue } from "./event-presentation.js";
+
+const TOOL_EVENTS = new Set([
+  "tool.payload.started",
+  "tool.payload.completed",
+  "tool.payload.failed",
+  "tool.approval.required",
+  "tool.approval.granted",
+  "tool.approval.rejected",
+  "tool.started",
+  "tool.completed",
+  "tool.failed",
+]);
+
+function boundedText(value, limit = 500) {
+  if (typeof value !== "string") return "";
+  return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+}
+
+function finiteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function payloadStageMetadata(message) {
+  if (!Number.isSafeInteger(message.payloadStage)) return {};
+  if (!Number.isSafeInteger(message.payloadStageCount)) return {};
+  if (message.payloadStage < 1) return {};
+  if (message.payloadStage > message.payloadStageCount) return {};
+  return {
+    payloadStage: message.payloadStage,
+    payloadStageCount: message.payloadStageCount,
+  };
+}
+
+function addText(fields, label, value) {
+  const text = boundedText(value).trim();
+  if (text) fields.push({ label, value: text });
+}
+
+function addCount(fields, label, value) {
+  if (finiteCount(value)) fields.push({ label, value: String(value) });
+}
+
+function lineRange(start, end) {
+  if (!finiteCount(start)) return "";
+  return finiteCount(end) ? `${start}–${end}` : `From ${start}`;
+}
+
+function inputFields(meta, completed, tool) {
+  const fields = [];
+  addText(fields, "Query", meta.query);
+  addText(fields, "Path", meta.path);
+  if (!meta.source || meta.displayTarget !== ".")
+    addText(fields, "Target", meta.displayTarget);
+  addText(fields, "Source", meta.source);
+  addText(fields, "Folder", meta.searchRoot);
+  addText(fields, "Mode", meta.searchMode);
+  addText(fields, "Find", meta.locator);
+  addText(fields, "Instruction", meta.instruction);
+  addText(fields, "Memory ID", meta.id);
+  addText(
+    fields,
+    tool === "edit_file" ? "Instruction" : "Content excerpt",
+    meta.inputPreview,
+  );
+  addCount(fields, "Content characters", meta.contentLength);
+  addCount(fields, "Offset", meta.offset ?? meta.params?.offset);
+  addCount(fields, "Limit", meta.limit ?? meta.params?.limit);
+  addCount(fields, "Depth", meta.depth);
+  addCount(fields, "Maximum depth", meta.maxDepth);
+  addCount(fields, "Maximum entries", meta.maxEntries);
+  addCount(fields, "Maximum symbols", meta.maxSymbols);
+  addCount(fields, "Character limit", meta.maxChars);
+  if (!completed)
+    addCount(fields, "Requested character offset", meta.startChar);
+  if (!completed)
+    addText(fields, "Requested lines", lineRange(meta.startLine, meta.endLine));
+  return fields;
+}
+
+function resultCountLabel(tool) {
+  if (tool === "memory_get") return "Stored records";
+  if (tool === "memory_search") return "Matching records";
+  if (tool === "local_search") return "Returned matches";
+  if (tool === "web_search") return "Results";
+  return "Items";
+}
+
+function resultFields(meta, tool, ok) {
+  const fields = [];
+  if (hasCompletedFileWindow(meta, ok)) {
+    addText(fields, "Read lines", lineRange(meta.startLine, meta.endLine));
+  }
+  addText(
+    fields,
+    "Changed lines",
+    lineRange(meta.changedStartLine, meta.changedEndLine),
+  );
+  addText(fields, "Edit", titleCaseEventValue(meta.operation));
+  addCount(fields, "Bytes", meta.byteCount);
+  addCount(fields, "Input bytes", meta.inputBytes);
+  addCount(fields, "File lines", meta.lineCount);
+  addCount(fields, "Total characters", meta.totalCharacters);
+  if (ok === true && tool === "document_reader") {
+    addCount(fields, "Start character", meta.startChar);
+    addCount(fields, "End character", meta.endChar);
+  }
+  addCount(fields, "Directory entries", meta.returnedEntries);
+  addResultCounts(fields, meta, tool);
+  addCount(fields, "Deleted records", meta.deletedCount);
+  addCount(fields, "Next offset", meta.nextOffset);
+  addText(fields, "Saved memory ID", meta.savedId);
+  addText(fields, "Document", meta.documentName);
+  if (typeof meta.syntaxValid === "boolean") {
+    addText(fields, "JSON syntax", meta.syntaxValid ? "Valid" : "Invalid");
+  }
+  addText(fields, "Error", meta.errorCode);
+  if (meta.state === "establish_target")
+    addText(fields, "Change", "Created file");
+  if (meta.state === "refine_target")
+    addText(fields, "Change", "Replaced file contents");
+  return fields;
+}
+
+function hasCompletedFileWindow(meta, ok) {
+  if (ok !== true) return false;
+  if (meta.mode !== "file") return false;
+  if (meta.hasData === false) return false;
+  return meta.locatorFound !== false;
+}
+
+function addResultCounts(fields, meta, tool) {
+  if (tool === "inspect_code_outline") {
+    addCount(fields, "Returned symbols", meta.returnedItemCount);
+    addCount(fields, "Total symbols", meta.totalItemCount);
+    return;
+  }
+  if (tool === "memory_get" || tool === "memory_search") {
+    addCount(fields, "Returned records", meta.returnedItemCount);
+    addCount(
+      fields,
+      resultCountLabel(tool),
+      meta.totalItemCount ?? meta.itemCount,
+    );
+    return;
+  }
+  if (tool === "local_search") {
+    addCount(
+      fields,
+      "Returned matches",
+      meta.returnedItemCount ?? meta.itemCount,
+    );
+    return;
+  }
+  if (tool === "dev_view" || tool === "read_file") return;
+  addCount(fields, resultCountLabel(tool), meta.itemCount);
+}
+
+function hasPartialSource(meta) {
+  if (meta.truncated === true) return true;
+  if (meta.scanTruncated === true) return true;
+  if (meta.outputTruncated === true) return true;
+  if (meta.sourceTruncated === true) return true;
+  if (meta.importsTruncated === true) return true;
+  return meta.complete === false;
+}
+
+function completedOutcome(meta) {
+  if (meta.state === "unchanged" || meta.stateAlreadySatisfied === true)
+    return "unchanged";
+  if (meta.locatorFound === false) return "empty";
+  if (meta.hasData === false || meta.deletedCount === 0) return "empty";
+  return "completed";
+}
+
+/** Retain only bounded display evidence; arbitrary event metadata stays out of UI state. */
+export function projectToolActivityEvent(message) {
+  const name =
+    message.eventName || message.name || message.rawType || message.type;
+  if (!TOOL_EVENTS.has(name)) return null;
+  const tool = boundedText(message.tool, 128).trim();
+  if (!tool) return null;
+  const meta = effectiveToolMetadata(getRecord(message.meta) || {}, tool);
+  const completed = name === "tool.completed";
+  const params = getRecord(meta.params);
+  const inputMeta = { ...meta, params };
+  return {
+    name,
+    tool,
+    executionId: boundedText(message.executionId, 200).trim(),
+    executorRole: boundedText(message.executorRole, 128).trim(),
+    roleCallId: boundedText(message.roleCallId, 200).trim(),
+    ...payloadStageMetadata(message),
+    beforeExternalExecution: message.stage === "before_external_execution",
+    intent: boundedText(message.intent || meta.intent),
+    target: boundedText(
+      meta.source ||
+        meta.displayTarget ||
+        meta.path ||
+        meta.searchRoot ||
+        meta.query ||
+        meta.id ||
+        meta.savedId,
+    ),
+    sent: inputFields(inputMeta, completed, tool),
+    received: completed ? resultFields(meta, tool, message.ok) : [],
+    preview: completed ? boundedText(meta.outputPreview, 1_200) : "",
+    previewTruncated: completed && hasClippedPreview(meta),
+    partial: completed && hasPartialSource(meta),
+    outcome: completedOutcome(meta),
+    ok: typeof message.ok === "boolean" ? message.ok : null,
+    error: boundedText(message.error || message.reason || meta.errorCode),
+  };
+}
+
+function effectiveToolMetadata(meta, tool) {
+  if (tool !== "document_reader") return meta;
+  if (meta.sourceMode === "working_path") return { ...meta, source: undefined };
+  return { ...meta, displayTarget: undefined };
+}
+
+function hasClippedPreview(meta) {
+  if (meta.outputPreviewTruncated === true) return true;
+  if (meta.evidenceTruncated === true) return true;
+  return (
+    typeof meta.outputPreview === "string" && meta.outputPreview.length > 1_200
+  );
+}

package/dist/src/web-ui/app/lib/tool-activity-model.d.ts

@@ -0,0 +1,41 @@
+export interface ToolActivityField {
+  label: string;
+  value: string;
+}
+
+export interface ConversationToolAction {
+  id: string;
+  tool: string;
+  executorRole?: string;
+  roleCallId?: string;
+  title: string;
+  target: string;
+  status:
+    | "preparing"
+    | "running"
+    | "awaiting_approval"
+    | "completed"
+    | "failed"
+    | "empty"
+    | "unchanged"
+    | "incomplete";
+  statusLabel: string;
+  intent: string;
+  sent: ToolActivityField[];
+  received: ToolActivityField[];
+  preview: string;
+  previewTruncated: boolean;
+  executed: boolean;
+  partial: boolean;
+  legacy: boolean;
+  count: number;
+}
+
+export declare function buildConversationToolActions(input: {
+  requestId: string;
+  events?: Record<string, unknown>[];
+  streaming?: boolean;
+}): ConversationToolAction[];
+export declare function summarizeConversationTools(
+  actions: ConversationToolAction[],
+): string;