@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/web-ui/app/lib/schedule-errors.js

@@ -0,0 +1,29 @@
+const SCHEDULE_ERRORS = {
+  scheduler_store_in_use:
+    "Schedules are being managed by another ABot process. This window cannot access them right now.",
+  scheduler_unavailable: "The scheduling service is not available right now.",
+  scheduler_stopped:
+    "The scheduling service has stopped. Reconnect after ABot starts again.",
+  scheduler_job_not_found:
+    "This schedule is no longer available. Refresh the list to see current schedules.",
+  scheduler_job_cancelled:
+    "This schedule has been cancelled and cannot run again.",
+  scheduler_session_deleted: "The conversation for this schedule was deleted.",
+  scheduler_session_not_found:
+    "The conversation for this schedule is no longer available.",
+  scheduler_model_required: "Choose a model for this schedule.",
+  scheduler_model_unavailable:
+    "The saved model is unavailable. Choose another configured model.",
+  scheduler_schedule_in_past: "Choose a date and time in the future.",
+};
+
+export function scheduleErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error || "");
+  const [code, ...details] = message.split(":");
+  if (SCHEDULE_ERRORS[code]) return SCHEDULE_ERRORS[code];
+  if (details.length && code.startsWith("scheduler_"))
+    return details.join(":").trim();
+  if (/^[a-z][a-z0-9]*_[a-z0-9_]+$/.test(message))
+    return "This schedule request could not be completed. Refresh and try again.";
+  return message || "Schedules could not be loaded. Refresh and try again.";
+}

package/dist/src/web-ui/app/lib/schedule-message.js

@@ -0,0 +1,30 @@
+import { textOf } from "./text-format.js";
+
+export function normalizeScheduleReference(raw) {
+  if (!raw || typeof raw !== "object") return undefined;
+  const jobId = textOf(raw.jobId).trim();
+  const runId = textOf(raw.runId).trim();
+  if (!jobId || !runId) return undefined;
+  return {
+    jobId,
+    runId,
+    title: textOf(raw.title).trim() || "Scheduled task",
+    scheduledAt: textOf(raw.scheduledAt),
+    triggerType: textOf(raw.triggerType),
+  };
+}
+
+export function scheduleTimeLabel(value, timeZone) {
+  if (!value) return "—";
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) return "—";
+  try {
+    return new Intl.DateTimeFormat(undefined, {
+      dateStyle: "medium",
+      timeStyle: "short",
+      ...(timeZone ? { timeZone } : {}),
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}

package/dist/src/web-ui/app/lib/schedule-presentation.js

@@ -0,0 +1,81 @@
+import { scheduleTimeLabel } from "./schedule-message.js";
+export { scheduleErrorMessage } from "./schedule-errors.js";
+
+export const SCHEDULE_WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+];
+
+export function scheduleDurationLabel(milliseconds) {
+  const minutes = milliseconds / 60000;
+  if (minutes % 1440 === 0) return `${minutes / 1440} days`;
+  if (minutes % 60 === 0) return `${minutes / 60} hours`;
+  return `${minutes} minutes`;
+}
+
+export function scheduleDescription(job) {
+  const schedule = job.schedule;
+  if (!schedule) return "Schedule unavailable";
+  if (schedule.kind === "timer")
+    return `After ${scheduleDurationLabel(schedule.delayMs)}`;
+  if (schedule.kind === "once")
+    return scheduleTimeLabel(schedule.at, job.timeZone);
+  if (schedule.kind === "interval")
+    return `Every ${scheduleDurationLabel(schedule.everyMs)}`;
+  if (schedule.kind === "daily") return `Daily at ${schedule.at}`;
+  if (schedule.kind === "weekly")
+    return `${schedule.weekdays.map((day) => SCHEDULE_WEEKDAYS[day]).join(", ")} at ${schedule.at}`;
+  if (schedule.kind === "monthly")
+    return `Day ${schedule.dayOfMonth} each month at ${schedule.at}`;
+  return "Schedule unavailable";
+}
+
+function matchesScheduleState(job, state) {
+  if (!state || state === "all") return true;
+  if (state === "current") return ["active", "paused"].includes(job.state);
+  return job.state === state;
+}
+
+export function matchesScheduleFilter(job, query, state, sessions = []) {
+  if (!matchesScheduleState(job, state)) return false;
+  const needle = String(query || "")
+    .trim()
+    .toLocaleLowerCase();
+  if (!needle) return true;
+  const session = sessions.find((item) => item.id === job.sessionId);
+  return [
+    job.title,
+    job.prompt,
+    job.sessionId,
+    session?.title,
+    job.modelProfileId,
+    scheduleDescription(job),
+  ].some((value) =>
+    String(value || "")
+      .toLocaleLowerCase()
+      .includes(needle),
+  );
+}
+
+export function canManageSchedule(job) {
+  if (!job) return false;
+  return job.state !== "cancelled";
+}
+
+export function canRunScheduleNow(job) {
+  if (!job) return false;
+  return job.state !== "cancelled";
+}
+
+export function emptyScheduleListMessage(snapshot) {
+  if (snapshot.loading) return "Loading…";
+  if (snapshot.error)
+    return "The schedule list is unavailable. Refresh to load it again.";
+  if (snapshot.jobs.length) return "No schedules match your search.";
+  return "No schedules yet. Create one here or ask ABot in a conversation.";
+}

package/dist/src/web-ui/app/lib/session-read-state.d.ts

@@ -0,0 +1,22 @@
+export type SessionReadStateEntry = Record<string, unknown> & {
+  id?: unknown;
+  lastReadAt?: unknown;
+  readState?: Record<string, unknown>;
+};
+
+export declare function isOlderSessionReadState(
+  incoming: SessionReadStateEntry | null | undefined,
+  known: SessionReadStateEntry | null | undefined,
+): boolean;
+
+export declare function isSessionReadStateUnavailable(
+  value: SessionReadStateEntry | null | undefined,
+): boolean;
+
+export declare function mergeSessionReadStateUpdate<
+  T extends SessionReadStateEntry,
+>(incoming: T, known: SessionReadStateEntry | null | undefined): T;
+
+export declare function mergeSessionListReadState<
+  T extends SessionReadStateEntry,
+>(incomingSessions: T[], knownSessions: SessionReadStateEntry[]): T[];

package/dist/src/web-ui/app/lib/session-read-state.js

@@ -0,0 +1,63 @@
+function sessionReadTimestamp(value) {
+  const timestamp = value?.lastReadAt ?? value?.readState?.lastReadAt;
+  if (typeof timestamp !== "number") return null;
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function sessionReadStateStatus(value) {
+  return value?.readStateStatus ?? value?.readState?.readStateStatus;
+}
+
+export function isSessionReadStateUnavailable(value) {
+  return sessionReadStateStatus(value) === "unavailable";
+}
+
+export function isOlderSessionReadState(incoming, known) {
+  if (isSessionReadStateUnavailable(incoming)) return false;
+  const incomingTimestamp = sessionReadTimestamp(incoming);
+  const knownTimestamp = sessionReadTimestamp(known);
+  if (incomingTimestamp === null) return false;
+  if (knownTimestamp === null) return false;
+  return incomingTimestamp < knownTimestamp;
+}
+
+function preserveKnownReadState(incoming, known) {
+  if (!known) return incoming;
+  const preserveUnavailable = isSessionReadStateUnavailable(incoming);
+  if (!preserveUnavailable && !isOlderSessionReadState(incoming, known))
+    return incoming;
+  const preserved = {};
+  for (const field of [
+    "lastReadAt",
+    "lastReadMessageId",
+    "unreadCount",
+    "hasUnread",
+  ]) {
+    preserved[field] = known[field] ?? known.readState?.[field] ?? null;
+  }
+  return {
+    ...incoming,
+    ...preserved,
+    readState: {
+      ...incoming.readState,
+      sessionId: incoming.id ?? incoming.sessionId,
+      readStateStatus: sessionReadStateStatus(incoming),
+      ...preserved,
+    },
+  };
+}
+
+export function mergeSessionReadStateUpdate(incoming, known) {
+  const merged = preserveKnownReadState(incoming, known);
+  if (!isSessionReadStateUnavailable(known)) return merged;
+  return { ...merged, readStateStatus: "unavailable" };
+}
+
+export function mergeSessionListReadState(incomingSessions, knownSessions) {
+  const knownById = new Map(
+    knownSessions.map((session) => [session.id, session]),
+  );
+  return incomingSessions.map((session) =>
+    preserveKnownReadState(session, knownById.get(session.id)),
+  );
+}

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;