@abot-ai/runtime 1.1.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-invocation-count.d.ts

@@ -0,0 +1,5 @@
+import type { EventRecord } from "./event-presentation.js";
+
+export declare function countToolInvocations(
+  events: readonly EventRecord[],
+): number;

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

@@ -0,0 +1,21 @@
+function isToolInvocationStart(event) {
+  return event.eventName === "tool.started";
+}
+
+function hasFiniteInvocationMultiplicity(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function toolInvocationMultiplicity(event) {
+  if (!hasFiniteInvocationMultiplicity(event.count)) return 1;
+  return Math.max(1, event.count);
+}
+
+export function countToolInvocations(events) {
+  let count = 0;
+  for (const event of events) {
+    if (!isToolInvocationStart(event)) continue;
+    count += toolInvocationMultiplicity(event);
+  }
+  return count;
+}

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/lib/web-source-event.d.ts

@@ -0,0 +1,8 @@
+import type { normalizeWebSources } from "./web-sources.js";
+import type { normalizeLegacyWebSources } from "./web-sources.js";
+
+export declare function projectWebSourceEvent(
+  message: Record<string, unknown>,
+):
+  | ReturnType<typeof normalizeWebSources>
+  | ReturnType<typeof normalizeLegacyWebSources>;

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

@@ -0,0 +1,21 @@
+import {
+  normalizeLegacyWebSources,
+  normalizeWebSources,
+} from "./web-sources.js";
+
+function isCompletedWebTool(message) {
+  const name = message.name || message.rawType || message.type;
+  if (name !== "tool.completed") return false;
+  if (message.ok !== true) return false;
+  return message.tool === "web_search" || message.tool === "web_fetch";
+}
+
+export function projectWebSourceEvent(message) {
+  if (!isCompletedWebTool(message)) return null;
+  const meta = message.meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return null;
+  if (Object.hasOwn(meta, "webSources")) {
+    return normalizeWebSources(meta.webSources, message.tool);
+  }
+  return normalizeLegacyWebSources(meta, message.tool);
+}

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

@@ -0,0 +1,36 @@
+export type WebSourceRetrieval = "not_attempted" | "retrieved" | "failed";
+export type WebSourcePresentation =
+  | "omitted"
+  | "reference"
+  | "snippet"
+  | "content";
+export type WebSource = {
+  url: string;
+  requestedUrl?: string;
+  title: string;
+  retrieval: WebSourceRetrieval;
+  presentation: WebSourcePresentation | "unknown";
+  contentTruncated: boolean;
+};
+export type WebSourcesReceipt = {
+  version: 0 | 1;
+  operation: "search" | "fetch";
+  provider?: "brave" | "light";
+  sources: WebSource[];
+  omittedSourceCount?: number;
+};
+export type ConversationSourcesGroup = WebSourcesReceipt & {
+  id: string;
+  callId: string;
+};
+export declare function normalizeWebSources(
+  value: unknown,
+  toolName: unknown,
+): WebSourcesReceipt | null;
+export declare function normalizeLegacyWebSources(
+  value: unknown,
+  toolName: unknown,
+): WebSourcesReceipt | null;
+export declare function buildConversationSources(
+  events?: unknown[],
+): ConversationSourcesGroup[];

package/dist/src/web-ui/app/lib/web-sources.js

@@ -0,0 +1,177 @@
+import { parseWebSourceUrl } from "./source-url-policy.js";
+
+const MAX_SOURCES_PER_RECEIPT = 25;
+const RETRIEVAL_STATES = new Set(["not_attempted", "retrieved", "failed"]);
+const PRESENTATION_STATES = new Set([
+  "omitted",
+  "reference",
+  "snippet",
+  "content",
+]);
+
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+}
+
+function operationForTool(toolName) {
+  if (toolName === "web_search") return "search";
+  if (toolName === "web_fetch") return "fetch";
+  return "";
+}
+
+function sourceTitle(value, hostname) {
+  if (typeof value !== "string" || !value.trim()) return hostname;
+  return value.trim().slice(0, 256);
+}
+
+function normalizeSource(value, legacy = false) {
+  const source = record(value);
+  if (!source) return null;
+  const url = parseWebSourceUrl(source.url);
+  if (!url || !RETRIEVAL_STATES.has(source.retrieval)) return null;
+  const hasKnownPresentation = PRESENTATION_STATES.has(source.presentation);
+  const hasLegacyPresentation = legacy && source.presentation === "unknown";
+  if (!hasKnownPresentation && !hasLegacyPresentation) return null;
+  const hasUnretrievedContent =
+    source.presentation === "content" && source.retrieval !== "retrieved";
+  if (hasUnretrievedContent) return null;
+  if (typeof source.contentTruncated !== "boolean") return null;
+  const requestedUrl = parseWebSourceUrl(source.requestedUrl);
+  return {
+    url: url.href,
+    ...(requestedUrl ? { requestedUrl: requestedUrl.href } : {}),
+    title: sourceTitle(source.title, url.hostname),
+    retrieval: source.retrieval,
+    presentation: source.presentation,
+    contentTruncated: source.contentTruncated,
+  };
+}
+
+function normalizeReceipt(value, toolName, legacy = false) {
+  const receipt = record(value);
+  const operation = operationForTool(toolName);
+  if (!receipt || !operation || receipt.operation !== operation) return null;
+  if (receipt.version !== (legacy ? 0 : 1)) return null;
+  if (!Array.isArray(receipt.sources)) return null;
+  if (receipt.sources.length > MAX_SOURCES_PER_RECEIPT) return null;
+  const omittedSourceCount = legacy ? 0 : receipt.omittedSourceCount;
+  const hasOmittedSourceCount =
+    !legacy && Object.hasOwn(receipt, "omittedSourceCount");
+  if (hasOmittedSourceCount && !Number.isSafeInteger(omittedSourceCount))
+    return null;
+  if (hasOmittedSourceCount && omittedSourceCount < 0) return null;
+  if (
+    hasOmittedSourceCount &&
+    receipt.sources.length + omittedSourceCount > MAX_SOURCES_PER_RECEIPT
+  )
+    return null;
+  const sources = receipt.sources
+    .map((source) => normalizeSource(source, legacy))
+    .filter(Boolean);
+  const provider = ["brave", "light"].includes(receipt.provider)
+    ? receipt.provider
+    : undefined;
+  return {
+    version: receipt.version,
+    operation,
+    ...(provider ? { provider } : {}),
+    ...(omittedSourceCount > 0 ? { omittedSourceCount } : {}),
+    sources,
+  };
+}
+
+export function normalizeWebSources(value, toolName) {
+  return normalizeReceipt(value, toolName);
+}
+
+function normalizedUrlSet(values) {
+  if (!Array.isArray(values)) return new Set();
+  return new Set(
+    values
+      .slice(0, MAX_SOURCES_PER_RECEIPT)
+      .map((value) => parseWebSourceUrl(value)?.href)
+      .filter(Boolean),
+  );
+}
+
+export function normalizeLegacyWebSources(value, toolName) {
+  const meta = record(value);
+  const operation = operationForTool(toolName);
+  if (!meta || !operation || !Array.isArray(meta.urls)) return null;
+  if (meta.urls.length > MAX_SOURCES_PER_RECEIPT) return null;
+  const fetched = normalizedUrlSet(meta.fetchedUrls);
+  const partial = normalizedUrlSet(meta.partialFetchedUrls);
+  const sources = meta.urls.flatMap((value) => {
+    const url = parseWebSourceUrl(value);
+    if (!url) return [];
+    const wasFetched =
+      operation === "fetch" || fetched.has(url.href) || partial.has(url.href);
+    return [
+      {
+        url: url.href,
+        title: url.hostname,
+        retrieval: wasFetched ? "retrieved" : "not_attempted",
+        presentation: "unknown",
+        contentTruncated: false,
+      },
+    ];
+  });
+  return {
+    version: 0,
+    operation,
+    ...(record(meta.lightSearch)?.provider === "light"
+      ? { provider: "light" }
+      : {}),
+    sources,
+  };
+}
+
+function eventReceipt(event) {
+  const toolName = event.tool;
+  if (event.webSources?.version === 0) {
+    return normalizeReceipt(event.webSources, toolName, true);
+  }
+  return normalizeWebSources(event.webSources, toolName);
+}
+
+function replayIdentity(event) {
+  const requestId = typeof event.requestId === "string" ? event.requestId : "";
+  const callId = typeof event.callId === "string" ? event.callId : "";
+  const originalSequence = event.eventSequence;
+  if (Number.isSafeInteger(originalSequence) && originalSequence > 0) {
+    return `${requestId}|${callId}|event:${originalSequence}`;
+  }
+  const transportSequence = event.seqNo ?? event.lastSeqNo;
+  if (Number.isSafeInteger(transportSequence) && transportSequence > 0) {
+    return `${requestId}|${callId}|transport:${transportSequence}`;
+  }
+  return callId ? `${requestId}|${callId}` : "";
+}
+
+export function buildConversationSources(events = []) {
+  if (!Array.isArray(events)) return [];
+  const groups = [];
+  const seen = new Set();
+  for (const value of events) {
+    const event = record(value);
+    if (!event || (event.eventName || event.name) !== "tool.completed")
+      continue;
+    const receipt = eventReceipt(event);
+    if (!receipt) continue;
+    const hasSourceEvidence =
+      receipt.sources.length > 0 || receipt.omittedSourceCount > 0;
+    if (!hasSourceEvidence) continue;
+    const identity = replayIdentity(event);
+    const replayKey = identity ? `${identity}|${JSON.stringify(receipt)}` : "";
+    if (replayKey && seen.has(replayKey)) continue;
+    if (replayKey) seen.add(replayKey);
+    groups.push({
+      ...receipt,
+      id: identity || `source-call-${groups.length + 1}`,
+      callId: typeof event.callId === "string" ? event.callId : "",
+    });
+  }
+  return groups;
+}

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;
+};