@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/web-ui/app/lib/composer-plan-model.js

@@ -0,0 +1,108 @@
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function canonicalCount(value, fallback) {
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function itemStatus(value) {
+  const status = text(value).toLowerCase();
+  if (status === "done" || status === "completed") return "done";
+  if (status === "in_progress" || status === "active") return "active";
+  if (status === "blocked" || status === "failed") return "blocked";
+  if (status === "superseded") return "superseded";
+  return "pending";
+}
+
+function orderedItems(rawItems) {
+  if (!Array.isArray(rawItems)) return [];
+  return rawItems
+    .flatMap((item, index) => {
+      const title = text(item?.title);
+      if (!title) return [];
+      return [
+        {
+          id: text(item.id) || `item-${index}`,
+          title,
+          status: itemStatus(item.status),
+          order: canonicalCount(item.order, index + 1),
+        },
+      ];
+    })
+    .sort((left, right) => left.order - right.order);
+}
+
+function hasVisiblePlan(progress, items, summary) {
+  return items.length > 0 || Boolean(summary) || progress.hasSignal === true;
+}
+
+function previewStatusFor({ activeItem, items, completed, total }) {
+  if (activeItem) return "active";
+  const countsAreComplete = total > 0 && completed === total;
+  const allVisibleItemsDone =
+    items.length > 0 && items.every((item) => item.status === "done");
+  if (countsAreComplete && allVisibleItemsDone) return "done";
+  return "pending";
+}
+
+function planForMessage(message, getActivityForMessage) {
+  const requestId = text(message.requestId);
+  if (!requestId) return null;
+  const progress = getActivityForMessage(message)?.taskProgress;
+  if (!progress || text(progress.requestId) !== requestId) return null;
+  const items = orderedItems(progress.items);
+  const summary = text(progress.summary);
+  if (!hasVisiblePlan(progress, items, summary)) return null;
+  const completed = canonicalCount(
+    progress.completed,
+    items.filter((item) => item.status === "done").length,
+  );
+  const total = canonicalCount(progress.total, items.length);
+  const activeItem =
+    text(progress.activeItem) ||
+    items.find((item) => item.status === "active")?.title ||
+    "";
+  return {
+    requestId,
+    turnKey: `request:${requestId}`,
+    summary,
+    items,
+    total,
+    completed,
+    hasSignal: progress.hasSignal === true,
+    preview: activeItem || summary || items[0]?.title || "Preparing tasks...",
+    previewStatus: previewStatusFor({ activeItem, items, completed, total }),
+  };
+}
+
+export function buildComposerPlanModel({
+  messages = [],
+  activeRequestId = "",
+  getActivityForMessage = () => ({}),
+} = {}) {
+  const lastUserIndex = messages.findLastIndex(
+    (message) => message.role === "user",
+  );
+  const assistants = messages
+    .slice(lastUserIndex + 1)
+    .filter((message) => message.role === "assistant");
+  if (assistants.length === 0) {
+    const latestUser = messages[lastUserIndex];
+    return latestUser
+      ? planForMessage(latestUser, getActivityForMessage)
+      : null;
+  }
+  const activeId = text(activeRequestId);
+  const activeAssistant = activeId
+    ? assistants.findLast((message) => text(message.requestId) === activeId)
+    : null;
+  if (activeAssistant) {
+    return planForMessage(activeAssistant, getActivityForMessage);
+  }
+  for (const message of [...assistants].reverse()) {
+    const plan = planForMessage(message, getActivityForMessage);
+    if (plan) return plan;
+  }
+  return null;
+}

package/dist/src/web-ui/app/lib/composer-submission-scope.d.ts

@@ -0,0 +1,21 @@
+export interface ComposerSubmissionView {
+  currentSessionId: string;
+  sessionViewVersion?: number;
+}
+
+export interface ComposerSubmissionScope {
+  environmentId: string;
+  sessionId: string;
+  viewVersion: number | undefined;
+}
+
+export declare function captureComposerSubmissionScope(
+  state: ComposerSubmissionView,
+  environmentId: string,
+): ComposerSubmissionScope;
+
+export declare function isCurrentComposerSubmissionScope(
+  scope: ComposerSubmissionScope,
+  state: ComposerSubmissionView,
+  environmentId: string,
+): boolean;

package/dist/src/web-ui/app/lib/composer-submission-scope.js

@@ -0,0 +1,13 @@
+export function captureComposerSubmissionScope(state, environmentId) {
+  return {
+    environmentId,
+    sessionId: state.currentSessionId,
+    viewVersion: state.sessionViewVersion,
+  };
+}
+
+export function isCurrentComposerSubmissionScope(scope, state, environmentId) {
+  if (scope.environmentId !== environmentId) return false;
+  if (scope.sessionId !== state.currentSessionId) return false;
+  return scope.viewVersion === state.sessionViewVersion;
+}

package/dist/src/web-ui/app/lib/context-window-snapshot-order.d.ts

@@ -0,0 +1,15 @@
+interface ContextWindowSequence {
+  eventSequence?: unknown;
+  seqNo?: unknown;
+  lastSeqNo?: unknown;
+}
+
+export declare function canReplaceContextWindowEvidence(
+  previous: ContextWindowSequence | null | undefined,
+  incoming: ContextWindowSequence,
+): boolean;
+
+export declare function isEventAfterContextWindowSnapshot(
+  snapshot: ContextWindowSequence,
+  event: ContextWindowSequence,
+): boolean;

package/dist/src/web-ui/app/lib/context-window-snapshot-order.js

@@ -0,0 +1,31 @@
+function positiveSequence(value) {
+  return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+
+function comparableSequenceDifference(previous, incoming) {
+  const previousOriginal = positiveSequence(previous?.eventSequence);
+  const incomingOriginal = positiveSequence(incoming?.eventSequence);
+  if (previousOriginal !== null && incomingOriginal !== null) {
+    return incomingOriginal - previousOriginal;
+  }
+  const previousTransport = positiveSequence(
+    previous?.seqNo ?? previous?.lastSeqNo,
+  );
+  const incomingTransport = positiveSequence(
+    incoming?.seqNo ?? incoming?.lastSeqNo,
+  );
+  if (previousTransport === null || incomingTransport === null) return null;
+  return incomingTransport - previousTransport;
+}
+
+export function canReplaceContextWindowEvidence(previous, incoming) {
+  const difference = comparableSequenceDifference(previous, incoming);
+  if (difference === null) return true;
+  return difference > 0;
+}
+
+export function isEventAfterContextWindowSnapshot(snapshot, event) {
+  const difference = comparableSequenceDifference(snapshot, event);
+  if (difference === null) return false;
+  return difference > 0;
+}

package/dist/src/web-ui/app/lib/conversation-role-model.d.ts

@@ -0,0 +1,28 @@
+import type { ConversationToolAction } from "./tool-activity-model.js";
+
+export type ConversationRole =
+  | "supervisor"
+  | "planner"
+  | "worker"
+  | "researcher"
+  | "reviewer"
+  | "unknown";
+
+export interface ConversationRoleCard {
+  id: string;
+  role: ConversationRole;
+  title: string;
+  responsibility: string;
+  phaseLabel: string;
+  summary: string;
+  facts: string[];
+  toolActions?: ConversationToolAction[];
+  active: boolean;
+  tone: "active" | "failed" | "recorded";
+}
+
+export function buildConversationRoleCards(input?: {
+  requestId?: unknown;
+  events?: unknown[];
+  streaming?: boolean;
+}): ConversationRoleCard[];

package/dist/src/web-ui/app/lib/conversation-role-model.js

@@ -0,0 +1,275 @@
+import {
+  eventTone,
+  formatEventDetail,
+  formatEventLabel,
+  titleCaseEventValue,
+} from "./event-presentation.js";
+import { textOf } from "./text-format.js";
+import { countToolInvocations } from "./tool-invocation-count.js";
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+import {
+  buildConversationToolActions,
+  summarizeConversationTools,
+} from "./tool-activity-model.js";
+
+const ROLE_TITLES = Object.freeze({
+  supervisor: "Supervisor",
+  planner: "Planner",
+  worker: "Worker",
+  researcher: "Researcher",
+  reviewer: "Reviewer",
+  unknown: "Unattributed actions",
+});
+
+const ROLE_RESPONSIBILITIES = Object.freeze({
+  supervisor: "Coordinates the request",
+  planner: "Plans the work",
+  worker: "Performs assigned tasks",
+  researcher: "Investigates assigned questions",
+  reviewer: "Reviews the result",
+  unknown: "Executor not recorded",
+});
+
+function latestRoleAction(group) {
+  if (group.toolActions.some((action) => !action.legacy)) {
+    return group.latestRoleEvent
+      ? roleActivitySummary(group.latestRoleEvent)
+      : "";
+  }
+  const toolEvent = group.toolEvents.at(-1);
+  return roleActivitySummary(toolEvent || group.latestEvent);
+}
+
+function belongsToRoleRequest(event, requestId) {
+  if (!event || typeof event !== "object") return false;
+  return textOf(event.requestId) === requestId;
+}
+
+function activityPosition(event) {
+  if (Number.isSafeInteger(event.eventSequence) && event.eventSequence > 0) {
+    return { domain: "runtime", value: event.eventSequence };
+  }
+  const replaySequence = event.lastSeqNo ?? event.seqNo;
+  if (Number.isSafeInteger(replaySequence) && replaySequence > 0) {
+    return { domain: "replay", value: replaySequence };
+  }
+  return null;
+}
+
+function orderedRequestActivity(events, requestId) {
+  const unique = [];
+  const seen = new Set();
+  const domains = new Map();
+  for (const event of events) {
+    if (!belongsToRoleRequest(event, requestId)) continue;
+    const position = activityPosition(event);
+    if (!position) {
+      unique.push({ event, position });
+      continue;
+    }
+    const identity = `${position.domain}:${position.value}`;
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    unique.push({ event, position });
+    const domain = domains.get(position.domain) || { events: [], next: 0 };
+    domain.events.push({ event, position });
+    domains.set(position.domain, domain);
+  }
+  for (const domain of domains.values()) {
+    domain.events.sort(
+      (left, right) => left.position.value - right.position.value,
+    );
+  }
+  // Runtime and replay cursors are separate counters. Sort only within each
+  // counter's existing slots, retaining arrival order for unsequenced history.
+  return unique.map(({ event, position }) => {
+    if (!position) return event;
+    const domain = domains.get(position.domain);
+    return domain.events[domain.next++].event;
+  });
+}
+
+function activityEventName(event) {
+  return textOf(event.eventName || event.name || event.rawType || event.type);
+}
+
+function isRequestTerminalEvent(event) {
+  if (event.type === "completed" || event.type === "failed") return true;
+  const name = activityEventName(event);
+  return name === "request.completed" || name === "request.failed";
+}
+
+function isToolActivityEvent(event) {
+  return activityEventName(event).startsWith("tool.");
+}
+
+function roleActivityStage(event) {
+  if (isToolActivityEvent(event)) return "";
+  return textOf(event.stage).trim();
+}
+
+function hasSupportedRoleStage(stage) {
+  return Object.hasOwn(ROLE_TITLES, stage);
+}
+
+function isFailedRoleActivity(event) {
+  return (textOf(event.tone) || eventTone(event)) === "failed";
+}
+
+function roleActivitySummary(event) {
+  return (
+    textOf(event.summary).trim() ||
+    formatEventDetail(event) ||
+    formatEventLabel(event)
+  );
+}
+
+function createRoleGroup(role, event) {
+  return {
+    role,
+    phase: "",
+    latestEvent: event,
+    latestRoleEvent: null,
+    toolEvents: [],
+    toolActions: [],
+  };
+}
+
+function isActiveRoleActivity(group, activeRole, streaming) {
+  if (!streaming) return false;
+  if (group.role !== activeRole) return false;
+  return !isFailedRoleActivity(group.latestEvent);
+}
+
+function canShowActiveRoles(streaming, terminalSeen) {
+  if (terminalSeen) return false;
+  return streaming;
+}
+
+function buildRoleCard(group, activeRole, streaming) {
+  const failed = isFailedRoleActivity(group.latestEvent);
+  const active = isActiveRoleActivity(group, activeRole, streaming);
+  const toolCount = countToolInvocations(group.toolEvents);
+  const toolSummary = summarizeConversationTools(group.toolActions);
+  let tone = "recorded";
+  if (active) tone = "active";
+  if (failed) tone = "failed";
+  return {
+    id: group.role,
+    role: group.role,
+    title:
+      group.role === "supervisor" && !group.latestRoleEvent
+        ? "Root agent"
+        : ROLE_TITLES[group.role],
+    responsibility: ROLE_RESPONSIBILITIES[group.role],
+    phaseLabel: titleCaseEventValue(group.phase),
+    summary: latestRoleAction(group),
+    toolActions: group.toolActions,
+    facts: toolSummary
+      ? [toolSummary]
+      : toolCount > 0
+        ? [`${toolCount} tool call${toolCount === 1 ? "" : "s"}`]
+        : [],
+    active,
+    tone,
+  };
+}
+
+export function buildConversationRoleCards({
+  requestId,
+  events = [],
+  streaming = false,
+} = {}) {
+  const normalizedRequestId = textOf(requestId).trim();
+  if (!normalizedRequestId) return [];
+
+  const groups = new Map();
+  let activeRole = "";
+  let terminalSeen = false;
+  const activityEvents = Array.isArray(events) ? events : [];
+  const orderedEvents = orderedRequestActivity(
+    activityEvents,
+    normalizedRequestId,
+  );
+  const executionOwners = recordedExecutionOwners(orderedEvents);
+  const toolEvents = [];
+  for (const event of orderedEvents) {
+    if (isRequestTerminalEvent(event)) {
+      terminalSeen = true;
+      activeRole = "";
+      continue;
+    }
+
+    const stage = roleActivityStage(event);
+    if (stage) {
+      activeRole = "";
+      if (hasSupportedRoleStage(stage)) {
+        activeRole = stage;
+        const group = groups.get(stage) || createRoleGroup(stage, event);
+        group.phase = textOf(event.phase);
+        group.latestEvent = event;
+        group.latestRoleEvent = event;
+        groups.set(stage, group);
+      }
+    }
+
+    if (!isToolActivityEvent(event)) continue;
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    const owner = toolExecutorRole(evidence, executionOwners, activeRole);
+    if (evidence)
+      toolEvents.push({
+        ...event,
+        toolActivity: { ...evidence, executorRole: owner },
+      });
+    if (!owner) continue;
+    const group = groups.get(owner) || createRoleGroup(owner, event);
+    group.latestEvent = event;
+    group.toolEvents.push({ ...event, eventName: activityEventName(event) });
+    groups.set(owner, group);
+  }
+
+  for (const action of buildConversationToolActions({
+    requestId: normalizedRequestId,
+    events: toolEvents,
+    streaming,
+  })) {
+    const owner = action.executorRole || "unknown";
+    const group = groups.get(owner) || createRoleGroup(owner, {});
+    group.toolActions.push(action);
+    groups.set(owner, group);
+  }
+
+  return [...groups.values()].map((group) =>
+    buildRoleCard(
+      group,
+      activeRole,
+      canShowActiveRoles(streaming, terminalSeen),
+    ),
+  );
+}
+
+function recordedExecutionOwners(events) {
+  const owners = new Map();
+  for (const event of events) {
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    if (!evidence?.executionId || !evidence.executorRole) continue;
+    const role = hasSupportedRoleStage(evidence.executorRole)
+      ? evidence.executorRole
+      : "unknown";
+    owners.set(evidence.executionId, role);
+  }
+  return owners;
+}
+
+function toolExecutorRole(evidence, executionOwners, activeRole) {
+  if (evidence?.executionId && executionOwners.has(evidence.executionId)) {
+    return executionOwners.get(evidence.executionId);
+  }
+  if (evidence?.executorRole) {
+    return hasSupportedRoleStage(evidence.executorRole)
+      ? evidence.executorRole
+      : "unknown";
+  }
+  if (evidence?.executionId) return "unknown";
+  return activeRole;
+}

package/dist/src/web-ui/app/lib/conversation-status-model.d.ts

@@ -0,0 +1,12 @@
+export interface ConversationStatus {
+  label: string;
+  animate: boolean;
+}
+
+export declare function buildConversationStatus(input?: {
+  requestId?: string;
+  streaming?: boolean;
+  connected?: boolean;
+  contextWindow?: Record<string, unknown> | null;
+  events?: Record<string, unknown>[];
+}): ConversationStatus | null;

package/dist/src/web-ui/app/lib/conversation-status-model.js

@@ -0,0 +1,116 @@
+import { buildConversationToolActions } from "./tool-activity-model.js";
+import { isEventAfterContextWindowSnapshot } from "./context-window-snapshot-order.js";
+import { textOf } from "./text-format.js";
+
+const MODEL_STEP_LABELS = Object.freeze({
+  "supervisor.decision": "Making a decision",
+  "execution.decision": "Making a decision",
+  "worker.decision": "Making a decision",
+  "capability.controls": "Making a decision",
+  "planner.decision": "Planning",
+  "planner.graph": "Planning",
+  "reviewer.decision": "Reviewing",
+  "auditor.decision": "Reviewing",
+  "worker.result": "Summarizing results",
+  "supervisor.response": "Preparing response",
+  "execution.response": "Preparing response",
+  "degraded.finalization": "Preparing response",
+  "context.compact": "Compacting context",
+  "tool_payload.raw": "Working",
+});
+
+const SETTLED_TOOL_EVENTS = new Set([
+  "tool.completed",
+  "tool.failed",
+  "tool.payload.failed",
+  "tool.approval.rejected",
+]);
+
+function hasToolStatus(actions, status) {
+  return actions.some((action) => action.status === status);
+}
+
+function hasMatchingContextRequest(contextWindow, requestId) {
+  return textOf(contextWindow?.requestId) === requestId;
+}
+
+function hasPendingRequestCompaction(contextWindow, requestId) {
+  if (!hasMatchingContextRequest(contextWindow, requestId)) return false;
+  return Boolean(contextWindow.pendingCompaction);
+}
+
+function hasAcceptedRequestSnapshot(contextWindow, requestId) {
+  if (!hasMatchingContextRequest(contextWindow, requestId)) return false;
+  const snapshot = contextWindow.snapshot;
+  if (!snapshot) return false;
+  if (textOf(snapshot.requestId) !== requestId) return false;
+  return snapshot.admissionOutcome === "accepted";
+}
+
+function isSettledToolAfterSnapshot(event, snapshot) {
+  const name = textOf(
+    event.toolActivity?.name ||
+      event.eventName ||
+      event.name ||
+      event.rawType ||
+      event.type,
+  );
+  if (!SETTLED_TOOL_EVENTS.has(name)) return false;
+  return isEventAfterContextWindowSnapshot(snapshot, event);
+}
+
+function hasUsageForCurrentInvocation(contextWindow) {
+  const invocationId = textOf(contextWindow.snapshot?.invocationId);
+  if (!invocationId) return false;
+  return textOf(contextWindow.providerUsage?.invocationId) === invocationId;
+}
+
+function activeStatus(label) {
+  return { label, animate: true };
+}
+
+function modelStepLabel(modelStep) {
+  if (!Object.hasOwn(MODEL_STEP_LABELS, modelStep)) return "Working";
+  return MODEL_STEP_LABELS[modelStep];
+}
+
+export function buildConversationStatus({
+  requestId,
+  streaming = false,
+  connected = true,
+  contextWindow = null,
+  events = [],
+} = {}) {
+  const activeRequestId = textOf(requestId).trim();
+  if (!activeRequestId) return null;
+  if (!streaming) return null;
+  if (!connected) return { label: "Reconnecting", animate: false };
+
+  const scopedEvents = events.filter(
+    (event) => event.requestId === activeRequestId,
+  );
+  const tools = buildConversationToolActions({
+    requestId: activeRequestId,
+    streaming: true,
+    events: scopedEvents,
+  });
+  if (hasToolStatus(tools, "awaiting_approval")) {
+    return { label: "Waiting for approval", animate: false };
+  }
+  if (hasToolStatus(tools, "running")) return activeStatus("Running tool");
+  if (hasPendingRequestCompaction(contextWindow, activeRequestId)) {
+    return activeStatus("Compacting context");
+  }
+  if (hasToolStatus(tools, "preparing")) return activeStatus("Working");
+  if (!hasAcceptedRequestSnapshot(contextWindow, activeRequestId)) {
+    return activeStatus("Working");
+  }
+  const snapshot = contextWindow.snapshot;
+  const settledAfterSnapshot = scopedEvents.some((event) =>
+    isSettledToolAfterSnapshot(event, snapshot),
+  );
+  if (settledAfterSnapshot) return activeStatus("Working");
+  if (hasUsageForCurrentInvocation(contextWindow))
+    return activeStatus("Working");
+  return activeStatus(modelStepLabel(snapshot.modelStep));
+}

package/dist/src/web-ui/app/lib/dashboard-job-templates.js

@@ -0,0 +1,41 @@
+const templates = [
+  {
+    id: "briefing",
+    title: "Morning briefing",
+    description: "A concise roundup of the day's important news.",
+    timingLabel: "Daily · 08:00",
+    schedule: { kind: "daily", at: "08:00" },
+    prompt: "Find the five most significant world news developments from the past 24 hours. Give each a short headline, a two-sentence factual summary, and a link to a reliable source. Keep the briefing under 400 words.",
+  },
+  {
+    id: "learning",
+    title: "Learn something new",
+    description: "One useful idea, with an example to make it stick.",
+    timingLabel: "Weekdays · 12:00",
+    schedule: { kind: "weekly", at: "12:00", weekdays: [1, 2, 3, 4, 5] },
+    prompt: "Teach me one useful idea from science, history, technology, or everyday life in under 250 words. Explain it in plain language, give one concrete example, and finish with a question I can think about.",
+  },
+  {
+    id: "reflection",
+    title: "Weekly reflection",
+    description: "Pause, reflect, and choose a priority for next week.",
+    timingLabel: "Sunday · 18:00",
+    schedule: { kind: "weekly", at: "18:00", weekdays: [0] },
+    prompt: "Create a short weekly reflection exercise: three questions about what went well, what was difficult, and what to change next week. Finish with a simple template for choosing one priority. Do not assume anything about my work or personal circumstances.",
+  },
+];
+
+export function getDashboardJobTemplates() {
+  return structuredClone(templates);
+}
+
+export function dashboardJobInitialValues(templateId, modelProfileId) {
+  const template = templates.find((item) => item.id === templateId);
+  return {
+    ...(template ? structuredClone(template) : {}),
+    newConversation: true,
+    modelProfileId,
+    agentMode: "reasoning",
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  };
+}