@abot-ai/runtime 1.2.0 → 1.3.0

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

@@ -0,0 +1,255 @@
+import { titleCaseEventValue } from "./event-presentation.js";
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+
+const TITLES = Object.freeze({
+  dev_view: "Read",
+  read_file: "Read file",
+  write_file: "Write file",
+  edit_file: "Edit file",
+  local_search: "Search files",
+  document_reader: "Read document",
+  inspect_project: "Inspect project",
+  inspect_json: "Inspect JSON",
+  inspect_code_outline: "Outline code",
+  memory_search: "Search memory",
+  memory_get: "Read memory",
+  memory_add: "Save memory",
+  memory_delete: "Delete memory",
+  web_search: "Search the web",
+  web_fetch: "Read web page",
+});
+
+const PHASES = Object.freeze({
+  "tool.payload.started": [1, "preparing", "Preparing"],
+  "tool.payload.completed": [2, "preparing", "Ready"],
+  "tool.approval.required": [3, "awaiting_approval", "Awaiting approval"],
+  "tool.approval.granted": [4, "preparing", "Approved"],
+  "tool.started": [5, "running", "Running"],
+  "tool.payload.failed": [6, "failed", "Preparation failed"],
+  "tool.approval.rejected": [6, "failed", "Not approved"],
+  "tool.failed": [6, "failed", "Failed"],
+  "tool.completed": [6, "completed", "Completed"],
+});
+
+const SETTLED_LABELS = Object.freeze({
+  completed: "Completed",
+  empty: "No results",
+  unchanged: "No change",
+  failed: "Failed",
+  incomplete: "Outcome not recorded",
+});
+
+function isSettledToolEvent(event) {
+  return PHASES[event.name]?.[0] === 6;
+}
+
+function mergeFields(previous, incoming) {
+  const fields = new Map(previous.map((field) => [field.label, field]));
+  for (const field of incoming) fields.set(field.label, field);
+  return [...fields.values()];
+}
+
+function initialAction(id, evidence, count) {
+  return {
+    id,
+    tool: evidence.tool,
+    executorRole: evidence.executorRole || "",
+    roleCallId: evidence.roleCallId || "",
+    title: TITLES[evidence.tool] || titleCaseEventValue(evidence.tool),
+    target: "",
+    status: "preparing",
+    statusLabel: "Preparing",
+    intent: "",
+    sent: [],
+    received: [],
+    preview: "",
+    previewTruncated: false,
+    partial: false,
+    executed: false,
+    legacy: !evidence.executionId,
+    count,
+  };
+}
+
+function completionStatus(evidence) {
+  if (evidence.ok === false) return "failed";
+  if (evidence.ok !== true) return "incomplete";
+  return evidence.outcome;
+}
+
+function applyPhase(action, evidence) {
+  const [, status, label] = PHASES[evidence.name];
+  action.status = status;
+  action.statusLabel = label;
+  if (evidence.name !== "tool.completed") return;
+  action.status = completionStatus(evidence);
+  action.statusLabel = SETTLED_LABELS[action.status];
+  if (evidence.tool === "memory_delete" && action.status === "empty") {
+    action.statusLabel = "No matching record";
+  }
+  if (evidence.tool === "dev_view" && action.status === "empty") {
+    action.statusLabel = "No match in scanned range";
+  }
+}
+
+function applyEvidence(action, evidence) {
+  if (evidence.executorRole) action.executorRole = evidence.executorRole;
+  if (evidence.roleCallId) action.roleCallId = evidence.roleCallId;
+  if (isExecutedToolEvent(evidence)) action.executed = true;
+  if (evidence.target) action.target = evidence.target;
+  if (evidence.intent) action.intent = evidence.intent;
+  action.sent =
+    evidence.name === "tool.completed"
+      ? mergeFields(evidence.sent, action.sent)
+      : mergeFields(action.sent, evidence.sent);
+  action.received = mergeFields(action.received, evidence.received);
+  if (evidence.error) {
+    action.received = mergeFields(action.received, [
+      { label: "Error", value: evidence.error },
+    ]);
+  }
+  if (evidence.preview) action.preview = evidence.preview;
+  if (evidence.name === "tool.completed")
+    action.previewTruncated = evidence.previewTruncated;
+  if (evidence.name === "tool.completed") action.partial = evidence.partial;
+}
+
+function isExecutedToolEvent(evidence) {
+  const { name, beforeExternalExecution } = evidence;
+  if (name === "tool.failed" && beforeExternalExecution) return false;
+  return (
+    name === "tool.started" ||
+    name === "tool.completed" ||
+    name === "tool.failed"
+  );
+}
+
+function eventSequence(event) {
+  if (Number.isSafeInteger(event.eventSequence) && event.eventSequence > 0)
+    return event.eventSequence;
+  return null;
+}
+
+function orderGroupEvents(entries) {
+  const sequenced = entries
+    .filter((entry) => entry.sequence !== null)
+    .sort((a, b) => a.sequence - b.sequence);
+  let next = 0;
+  return entries.map((entry) =>
+    entry.sequence === null ? entry : sequenced[next++],
+  );
+}
+
+function canAdvanceToolPhase(phase, evidence, nextRank) {
+  if (nextRank > 2) return nextRank >= phase.rank;
+  if (phase.rank > 2) return false;
+  if (!phase.payloadStage) return nextRank >= phase.rank;
+  if (!evidence.payloadStage) return nextRank >= phase.rank;
+  if (evidence.payloadStageCount !== phase.payloadStageCount) return false;
+  if (evidence.payloadStage !== phase.payloadStage) {
+    return evidence.payloadStage > phase.payloadStage;
+  }
+  return nextRank >= phase.rank;
+}
+
+function finishAction(group, streaming) {
+  const action = initialAction(
+    group.id,
+    group.entries[0].evidence,
+    group.count,
+  );
+  const phase = { rank: 0, payloadStage: 0, payloadStageCount: 0 };
+  for (const { evidence } of orderGroupEvents(group.entries)) {
+    applyEvidence(action, evidence);
+    const nextRank = PHASES[evidence.name][0];
+    if (!canAdvanceToolPhase(phase, evidence, nextRank)) continue;
+    phase.rank = nextRank;
+    if (evidence.payloadStage) {
+      phase.payloadStage = evidence.payloadStage;
+      phase.payloadStageCount = evidence.payloadStageCount;
+    }
+    applyPhase(action, evidence);
+  }
+  if (!streaming && phase.rank < 6) {
+    action.status = "incomplete";
+    action.statusLabel = "Completion not recorded";
+  }
+  return action;
+}
+
+/** Lifecycle correlation is exact. Older, uncorrelated history supplies outcome rows only. */
+export function buildConversationToolActions({
+  requestId,
+  events = [],
+  streaming = false,
+}) {
+  const groups = new Map();
+  const seen = new Set();
+  for (const [index, event] of events.entries()) {
+    if (event.requestId !== requestId) continue;
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    if (!evidence) continue;
+    const sequence = eventSequence(event);
+    if (sequence !== null && seen.has(sequence)) continue;
+    if (sequence !== null) seen.add(sequence);
+    if (!evidence.executionId && !isSettledToolEvent(evidence)) continue;
+    const id = evidence.executionId
+      ? JSON.stringify([requestId, evidence.executionId])
+      : JSON.stringify([
+          requestId,
+          "recorded",
+          sequence ?? event.lastSeqNo ?? event.seqNo ?? index,
+        ]);
+    const count = evidence.executionId
+      ? 1
+      : Math.max(1, Number(event.count) || 1);
+    const group = groups.get(id) || { id, count, entries: [] };
+    group.entries.push({ evidence, sequence });
+    groups.set(id, group);
+  }
+  return [...groups.values()].map((group) => finishAction(group, streaming));
+}
+
+const CATEGORIES = Object.freeze({
+  dev_view: "read",
+  read_file: "read",
+  document_reader: "read",
+  inspect_project: "project inspection",
+  inspect_json: "JSON inspection",
+  inspect_code_outline: "code outline",
+  write_file: "write",
+  edit_file: "edit",
+  local_search: "file search",
+  memory_search: "memory search",
+  memory_get: "memory lookup",
+  memory_add: "memory save",
+  memory_delete: "memory deletion",
+  web_search: "web search",
+  web_fetch: "web read",
+});
+
+export function summarizeConversationTools(actions) {
+  const counts = new Map();
+  for (const action of actions) {
+    const category = CATEGORIES[action.tool] || "tool action";
+    counts.set(category, (counts.get(category) || 0) + action.count);
+  }
+  const categories = [...counts];
+  const summary = categories
+    .slice(0, 3)
+    .map(
+      ([category, count]) =>
+        `${count} ${category}${count === 1 ? "" : pluralSuffix(category)}`,
+    )
+    .join(" · ");
+  const remaining = categories
+    .slice(3)
+    .reduce((total, [, count]) => total + count, 0);
+  return remaining
+    ? `${summary} · ${remaining} other action${remaining === 1 ? "" : "s"}`
+    : summary;
+}
+
+function pluralSuffix(category) {
+  return category.endsWith("search") ? "es" : "s";
+}

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

@@ -0,0 +1,3 @@
+export declare function isNonToolTimelineEvent(
+  event: Record<string, unknown>,
+): boolean;

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

@@ -0,0 +1,18 @@
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+
+/** Tool lifecycle belongs to the action rows; other diagnostics retain their timeline. */
+export function isNonToolTimelineEvent(event) {
+  const evidence = event.toolActivity || projectToolActivityEvent(event);
+  if (!evidence) return true;
+  if (evidence.executionId) return false;
+  return !isRecordedToolOutcome(evidence.name);
+}
+
+function isRecordedToolOutcome(name) {
+  return (
+    name === "tool.completed" ||
+    name === "tool.failed" ||
+    name === "tool.payload.failed" ||
+    name === "tool.approval.rejected"
+  );
+}

package/dist/src/web-ui/app/schedules-feature.js

@@ -0,0 +1,87 @@
+import { createSchedulesController } from "./controllers/schedules-controller.js";
+import { createSchedulesWorkspace } from "./components/schedules/workspace.js";
+
+export function createSchedulesFeature({
+  dom,
+  client,
+  shell,
+  selectedEnvironmentId,
+  getCurrentSessionId,
+  getAgentModes,
+  openSession,
+}) {
+  let view;
+  let active = false;
+  const controller = createSchedulesController({
+    client,
+    getEnvironmentId: selectedEnvironmentId,
+    render: (snapshot) => view?.render(snapshot),
+    openConversation: async (sessionId, requestId) => {
+      if (!shell.activateWorkspace("chat")) return;
+      if (!sessionId) return;
+      try {
+        await openSession(sessionId);
+        if (!requestId) return;
+        requestAnimationFrame(() => {
+          const messages = [
+            ...dom.messagesList.querySelectorAll("[data-request-id]"),
+          ];
+          const message = messages.find(
+            (node) => node.dataset.requestId === requestId,
+          );
+          message?.scrollIntoView({ block: "center", behavior: "smooth" });
+        });
+      } catch (error) {
+        shell.showToast(
+          error instanceof Error ? error.message : String(error),
+          "failed",
+        );
+      }
+    },
+  });
+  view = createSchedulesWorkspace({
+    root: dom.schedulesRoot,
+    actions: controller,
+    getCurrentSessionId,
+    getAgentModes,
+  });
+  view.render(controller.snapshot());
+  refreshAvailability();
+  dom.environmentSelect.addEventListener("change", () => {
+    queueMicrotask(() => {
+      if (active) void controller.load();
+    });
+  });
+  return {
+    refreshAvailability,
+    isWorkspaceAvailable(destination) {
+      if (destination !== "schedules") return true;
+      return client.supportsSchedules();
+    },
+    prepareLeave: view.prepareLeave,
+    setActive(value) {
+      active = value && client.supportsSchedules();
+      controller.setActive(active);
+    },
+    openJob(jobId) {
+      if (!client.supportsSchedules()) return;
+      if (!shell.activateWorkspace("schedules")) return;
+      void controller.openJob(jobId);
+    },
+    createJob(initialValues) {
+      if (!client.supportsSchedules()) return;
+      if (!shell.activateWorkspace("schedules")) return;
+      void controller.openCreate(initialValues);
+    },
+  };
+
+  function refreshAvailability() {
+    const available = client.supportsSchedules();
+    dom.schedulesWorkspaceButton.hidden = !available;
+    dom.schedulesWorkspaceButton.disabled = !available;
+    if (available) return;
+    controller.setActive(false);
+    if (active) shell.activateWorkspace("chat", { focus: false });
+    active = false;
+  }
+}

package/dist/src/web-ui/app/services/message-link-preview-client.d.ts

@@ -0,0 +1,14 @@
+export interface MessageLinkPreview {
+  url: string;
+  title: string;
+  description: string;
+  imageUrl: string;
+  siteName: string;
+}
+
+export declare function createMessageLinkPreviewClient(options?: {
+  fetchImpl?: typeof fetch | null;
+}): {
+  get(url: string): Promise<MessageLinkPreview | null>;
+  cancelQueued(): void;
+};

package/dist/src/web-ui/app/services/message-link-preview-client.js

@@ -0,0 +1,96 @@
+const MAX_ACTIVE_REQUESTS = 3;
+const MAX_QUEUED_REQUESTS = 64;
+const MAX_CACHED_PREVIEWS = 100;
+const PREVIEW_CACHE_LIFETIME_MS = 4 * 60 * 1_000;
+const PREVIEW_REQUEST_TIMEOUT_MS = 10_000;
+
+async function fetchLinkPreview(fetchImpl, url) {
+  if (typeof fetchImpl !== "function") return null;
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    PREVIEW_REQUEST_TIMEOUT_MS,
+  );
+  try {
+    const response = await fetchImpl(
+      `/web-link-preview?url=${encodeURIComponent(url)}`,
+      {
+        headers: { "X-Abot-Link-Preview": "1" },
+        credentials: "same-origin",
+        signal: controller.signal,
+      },
+    );
+    if (!response.ok) return null;
+    const payload = await response.json();
+    if (payload?.ok !== true) return null;
+    if (!payload.preview || typeof payload.preview !== "object") return null;
+    return payload.preview;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function createMessageLinkPreviewClient({
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const cache = new Map();
+  const pending = new Map();
+  const queue = [];
+  let activeRequests = 0;
+
+  function rememberPreview(url, preview) {
+    cache.delete(url);
+    cache.set(url, {
+      preview,
+      expiresAt: Date.now() + PREVIEW_CACHE_LIFETIME_MS,
+    });
+    if (cache.size > MAX_CACHED_PREVIEWS) {
+      cache.delete(cache.keys().next().value);
+    }
+  }
+
+  function startQueuedRequests() {
+    while (activeRequests < MAX_ACTIVE_REQUESTS && queue.length > 0) {
+      const job = queue.shift();
+      activeRequests += 1;
+      void fetchLinkPreview(fetchImpl, job.url).then((preview) => {
+        activeRequests -= 1;
+        pending.delete(job.url);
+        rememberPreview(job.url, preview);
+        job.resolve(preview);
+        startQueuedRequests();
+      });
+    }
+  }
+
+  function get(url) {
+    const cached = cache.get(url);
+    if (cached && cached.expiresAt > Date.now()) {
+      cache.delete(url);
+      cache.set(url, cached);
+      return Promise.resolve(cached.preview);
+    }
+    cache.delete(url);
+    if (pending.has(url)) return pending.get(url);
+    if (queue.length >= MAX_QUEUED_REQUESTS) return Promise.resolve(null);
+    let resolve;
+    const promise = new Promise((settle) => {
+      resolve = settle;
+    });
+    pending.set(url, promise);
+    queue.push({ url, resolve });
+    startQueuedRequests();
+    return promise;
+  }
+
+  function cancelQueued() {
+    for (const job of queue.splice(0)) {
+      pending.delete(job.url);
+      job.resolve(null);
+    }
+  }
+
+  return { get, cancelQueued };
+}

package/dist/src/web-ui/app/services/runtime-web-client/schedules.js

@@ -0,0 +1,51 @@
+export function createScheduleRequests({
+  requestApi,
+  getEnvironmentId,
+  getConfig,
+}) {
+  const supportsSchedules = () => getConfig()?.backend === "runtime";
+  const requestSchedules = async (url, options) => {
+    if (!supportsSchedules())
+      throw new Error("Schedules require the local Runtime backend.");
+    return requestApi(url, options);
+  };
+  const path = (suffix = "", environmentId = getEnvironmentId()) =>
+    `/schedules${suffix}?environment=${encodeURIComponent(environmentId)}`;
+  const runPagePath = (resourceSuffix, environmentId, page = {}) => {
+    const query = new URLSearchParams();
+    if (page.cursor !== undefined) query.set("cursor", page.cursor);
+    if (page.limit !== undefined) query.set("limit", String(page.limit));
+    const suffix = query.size ? `&${query}` : "";
+    return path(resourceSuffix, environmentId) + suffix;
+  };
+  return {
+    supportsSchedules,
+    listSchedules: (environmentId) => requestSchedules(path("", environmentId)),
+    getSchedule: (jobId, environmentId) =>
+      requestSchedules(path(`/${encodeURIComponent(jobId)}`, environmentId)),
+    listScheduleRuns: (jobId, environmentId, page) =>
+      requestSchedules(
+        runPagePath(`/${encodeURIComponent(jobId)}/runs`, environmentId, page),
+      ),
+    listRecentScheduleRuns: (environmentId, page) =>
+      requestSchedules(runPagePath("/runs", environmentId, page)),
+    createSchedule: (input, environmentId) =>
+      requestSchedules(path("", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      }),
+    updateSchedule: (jobId, input, environmentId) =>
+      requestSchedules(path(`/${encodeURIComponent(jobId)}`, environmentId), {
+        method: "PATCH",
+        body: JSON.stringify(input),
+      }),
+    scheduleAction: (jobId, action, environmentId) =>
+      requestSchedules(
+        path(`/${encodeURIComponent(jobId)}/${action}`, environmentId),
+        {
+          method: "POST",
+          body: "{}",
+        },
+      ),
+  };
+}

package/dist/src/web-ui/app/services/runtime-web-client.d.ts

@@ -1,3 +1,10 @@
+import type {
+  UpdateSchedulerJobInput,
+  SchedulerJob,
+  SchedulerRun,
+} from "../../../runtime/scheduler/contracts.js";
+import type { CreateWebScheduleJobInput } from "../../schedule-creation-contract.js";
+
 export declare function parseJsonResponseText(
   text: string,
   context: string,
@@ -61,6 +68,35 @@ export declare function createRuntimeWebClient(options: {
   fetchImpl?: typeof fetch;
   origin?: string;
 }): {
+  supportsSchedules(): boolean;
+  listSchedules(environmentId?: string): Promise<{ jobs: SchedulerJob[] }>;
+  getSchedule(
+    jobId: string,
+    environmentId?: string,
+  ): Promise<{ job: SchedulerJob }>;
+  listScheduleRuns(
+    jobId: string,
+    environmentId?: string,
+    page?: { cursor?: string; limit?: number },
+  ): Promise<{ runs: SchedulerRun[]; nextCursor: string | null }>;
+  listRecentScheduleRuns(
+    environmentId?: string,
+    page?: { cursor?: string; limit?: number },
+  ): Promise<{ runs: SchedulerRun[]; nextCursor: string | null }>;
+  createSchedule(
+    input: CreateWebScheduleJobInput,
+    environmentId?: string,
+  ): Promise<{ job: SchedulerJob }>;
+  updateSchedule(
+    jobId: string,
+    input: UpdateSchedulerJobInput,
+    environmentId?: string,
+  ): Promise<{ job: SchedulerJob }>;
+  scheduleAction(
+    jobId: string,
+    action: "pause" | "resume" | "cancel" | "run-now",
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
   getRuntimeStatus(): Promise<Record<string, unknown>>;
   getRuntimeLogs(lines?: number): Promise<Record<string, unknown>>;
   getSystemHealth(): Promise<Record<string, unknown>>;
@@ -101,6 +137,7 @@ export declare function createRuntimeWebClient(options: {
     sessionId: string;
     environmentId?: string;
     readThroughMessageId?: number | null;
+    readThroughRequestId?: string;
   }): Promise<Record<string, unknown>>;
   clearSessionMessages(
     sessionId: string,

package/dist/src/web-ui/app/services/runtime-web-client.js

@@ -1,3 +1,4 @@
+import { createScheduleRequests } from "./runtime-web-client/schedules.js";
 import { createLongTermMemoryRequests } from "./runtime-web-client/memory.js";
 
 export function parseJsonResponseText(text, context) {
@@ -176,24 +177,27 @@ export function createRuntimeWebClient({
       sessionId,
       environmentId = getEnvironmentId(),
       readThroughMessageId = null,
+      readThroughRequestId = "",
     }) {
       const numericReadThrough =
         typeof readThroughMessageId === "number" &&
         Number.isFinite(readThroughMessageId)
           ? Math.max(0, Math.floor(readThroughMessageId))
           : null;
+      const requestReadBoundary = numericReadThrough === null
+        ? String(readThroughRequestId || "").trim()
+        : "";
+      const body = {
+        readThroughMessageId: numericReadThrough,
+        lastReadMessageId:
+          numericReadThrough === null ? null : String(numericReadThrough),
+      };
+      if (requestReadBoundary) body.readThroughRequestId = requestReadBoundary;
       return requestApi(
         `/chat/sessions/${encodeURIComponent(
           sessionId,
         )}/read?environment=${environmentQuery(environmentId)}`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            readThroughMessageId: numericReadThrough,
-            lastReadMessageId:
-              numericReadThrough === null ? null : String(numericReadThrough),
-          }),
-        },
+        { method: "POST", body: JSON.stringify(body) },
       );
     },
 
@@ -292,5 +296,6 @@ export function createRuntimeWebClient({
     },
 
     ...longTermMemoryRequests,
+    ...createScheduleRequests({ requestApi, getEnvironmentId, getConfig }),
   };
 }

package/dist/src/web-ui/app/styles/00-tokens-base.css

@@ -28,17 +28,17 @@
     "Segoe UI Variable Display", "Segoe UI", Inter, system-ui, sans-serif;
   --font-mono: "Cascadia Code", "SFMono-Regular", Consolas, monospace;
   /* Readable typography shared by every workspace, including mobile. */
-  --font-size-xs: 0.875rem;
-  --font-size-sm: 0.9375rem;
-  --font-size-md: 1rem;
-  --font-size-lg: 1.0625rem;
-  --font-size-xl: 1.125rem;
-  --font-size-2xl: 1.25rem;
-  --font-size-3xl: 1.375rem;
-  --font-size-4xl: 1.5rem;
-  --font-size-5xl: 1.625rem;
-  --font-size-6xl: 1.875rem;
-  --font-size-7xl: 2.25rem;
+  --font-size-xs: 0.8125rem;
+  --font-size-sm: 0.875rem;
+  --font-size-md: 0.9375rem;
+  --font-size-lg: 1rem;
+  --font-size-xl: 1.0625rem;
+  --font-size-2xl: 1.1875rem;
+  --font-size-3xl: 1.3125rem;
+  --font-size-4xl: 1.4375rem;
+  --font-size-5xl: 1.5625rem;
+  --font-size-6xl: 1.8125rem;
+  --font-size-7xl: 2.1875rem;
   --sessions-panel-width: 320px;
   --chat-content-width: 900px;
   --scrollbar-thumb: rgba(95, 127, 158, 0.34);