@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,248 @@
+import { textOf } from "./text-format.js";
+
+export function buildEventTimelineEntries(events) {
+  const entries = [];
+  for (const event of events) {
+    const name = textOf(event.name || event.rawType || event.type);
+    if (!name) continue;
+    const summary = textOf(event.summary);
+    const previous = entries[entries.length - 1];
+    if (
+      previous &&
+      previous.name === name &&
+      previous.summary === summary &&
+      previous.tone === event.tone
+    ) {
+      previous.count = (previous.count || 1) + (event.count || 1);
+      continue;
+    }
+    entries.push({
+      ...event,
+      name,
+      summary,
+      count: event.count || 1,
+    });
+  }
+  return entries;
+}
+
+export function titleCaseEventValue(value) {
+  const normalized = textOf(value)
+    .replaceAll(/[_\.-]+/g, " ")
+    .replaceAll(/\s+/g, " ")
+    .trim();
+  if (!normalized) return "";
+  return normalized
+    .split(" ")
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+export function formatToolName(rawTool) {
+  const value = textOf(rawTool).trim();
+  if (!value) return "";
+  const known = {
+    write_file: "file writer",
+    read_file: "file reader",
+    read_files: "file reader",
+    text_editor: "text editor",
+    exec: "terminal",
+    web_search: "web search",
+    web_fetch: "web fetch",
+    memory_search: "memory search",
+    memory_get: "memory lookup",
+  };
+  return known[value] || titleCaseEventValue(value);
+}
+
+export function getRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+}
+
+export function getNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export function getPlanPayload(message) {
+  const plan = getRecord(message.plan);
+  if (!plan) return null;
+  const rawItems = Array.isArray(plan.items) ? plan.items : [];
+  const items = rawItems.flatMap((item) => {
+    const record = getRecord(item);
+    const title = textOf(record?.title).trim();
+    if (!title) return [];
+    return [
+      {
+        id: textOf(record.id),
+        title,
+        status: textOf(record.status, "pending"),
+        order: getNumber(record.order, 0),
+      },
+    ];
+  });
+  return {
+    summary: textOf(plan.summary),
+    total: getNumber(plan.total, items.length),
+    completed: getNumber(
+      plan.completed,
+      items.filter((item) => item.status === "done").length,
+    ),
+    items,
+  };
+}
+
+export function getPlanItemPayload(message) {
+  const item = getRecord(message.item);
+  const title = textOf(item?.title).trim();
+  if (!title) return null;
+  return {
+    id: textOf(item.id),
+    title,
+    status: textOf(item.status, "pending"),
+    order: getNumber(item.order, 0),
+  };
+}
+
+export function formatEventLabel(message) {
+  const name = textOf(message.name || message.rawType || message.type);
+  const status = textOf(message.status);
+  const phase = textOf(message.phase);
+
+  if (getPlanPayload(message) || getPlanItemPayload(message)) {
+    return name || "Development progress";
+  }
+  if (
+    name === "request_started" ||
+    name === "request.started" ||
+    name === "planning.started"
+  ) {
+    return "Preparing response";
+  }
+  if (name === "request_progress") {
+    if (phase === "awaiting_tokens") return "Preparing response";
+    if (phase === "awaiting_more_output") return "Answering";
+    if (status === "failed") return "Response failed";
+    return "Working";
+  }
+  if (
+    name === "thinking.started" ||
+    name === "thinking.delta" ||
+    name === "planning.retry" ||
+    name === "planning.failed"
+  ) {
+    return "Thinking";
+  }
+  if (name === "answer.started" || name === "token") return "Answering";
+  if (name === "request.completed" || message.type === "completed") {
+    return "Response ready";
+  }
+  if (name === "request.failed" || message.type === "failed") {
+    return "Response failed";
+  }
+  if (name === "runtime.state") {
+    return status || textOf(message.output) || "Runtime state";
+  }
+  if (name === "tool.intent") return "Next action";
+  if (name.startsWith("tool.")) {
+    const toolName = formatToolName(message.tool);
+    if (status) return status;
+    if (name === "tool.completed") {
+      return toolName ? `${toolName} completed` : "Tool completed";
+    }
+    if (name === "tool.failed") {
+      return toolName ? `${toolName} failed` : "Tool failed";
+    }
+    return toolName ? `Using ${toolName}` : "Using a tool";
+  }
+  return titleCaseEventValue(name) || "Event";
+}
+
+export function formatEventDetail(message) {
+  const parts = [];
+  const name = textOf(message.name || message.rawType || message.type);
+  const plan = getPlanPayload(message);
+  if (plan?.summary) parts.push(plan.summary);
+  const item = getPlanItemPayload(message);
+  if (item) {
+    parts.push(
+      item.order > 0
+        ? `item ${item.order}${plan?.total ? `/${plan.total}` : ""}`
+        : "plan item",
+    );
+  }
+  const intent = textOf(message.intent || getRecord(message.meta)?.intent);
+  if (name === "tool.approval.required") {
+    return intent || "Review this action before it runs.";
+  }
+  if (intent) parts.push(intent);
+  if (message.tool) parts.push(formatToolName(message.tool));
+  if (message.message) parts.push(textOf(message.message));
+  if (message.output && message.name !== "runtime.state") {
+    parts.push(textOf(message.output).slice(0, 120));
+  }
+  if (message.error) parts.push(`error=${message.error}`);
+  if (message.reason) parts.push(textOf(message.reason));
+  return parts.join(" | ");
+}
+
+export function eventTone(message) {
+  const name = textOf(message.name || message.type);
+  const normalized = name.toLowerCase();
+  if (
+    message.ok === false ||
+    textOf(message.status).toLowerCase() === "failed" ||
+    normalized.includes("failed") ||
+    normalized.includes("rejected") ||
+    normalized.includes("response failed") ||
+    message.type === "failed"
+  ) {
+    return "failed";
+  }
+  if (
+    normalized.includes("completed") ||
+    normalized.includes("complete") ||
+    normalized.includes("approved") ||
+    normalized.includes("response ready") ||
+    message.type === "completed"
+  ) {
+    return "done";
+  }
+  if (name === "thinking.delta") return "thinking";
+  return "active";
+}
+
+export function isLowValueActivityEvent(message) {
+  const name = textOf(message.name || message.rawType || message.type);
+  const type = textOf(message.type);
+  if (type === "failed" || name === "request.failed") return false;
+  return (
+    name === "request_started" ||
+    name === "request.started" ||
+    name === "request_progress" ||
+    name === "planning.started" ||
+    name === "thinking.started" ||
+    name === "thinking.delta" ||
+    name === "thinking.completed" ||
+    name === "context.window.snapshot" ||
+    name === "context.window.provider_usage" ||
+    name === "answer.started" ||
+    name === "token" ||
+    name === "request.completed" ||
+    type === "completed"
+  );
+}
+
+export function eventKeyFor(message, label, tone) {
+  const name = textOf(message.name || message.rawType || message.type);
+  const requestId = textOf(message.requestId);
+  const tool = textOf(message.tool);
+  const approvalId = textOf(message.approvalId);
+  const status = textOf(message.status);
+  const phase = textOf(message.phase);
+  return [requestId, name, label, tone, tool, approvalId, status, phase]
+    .filter(Boolean)
+    .join("|");
+}

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

@@ -0,0 +1,25 @@
+import { getRecord } from "./event-presentation.js";
+import { textOf } from "./text-format.js";
+
+export function normalizeRealtimeMessage(raw) {
+  const message = raw && typeof raw === "object" ? raw : {};
+  const payload = getRecord(message.payload);
+  return {
+    ...message,
+    ...(payload || {}),
+    type: textOf(message.type),
+    rawType: textOf(message.rawType || message.type),
+    requestId: textOf(message.requestId),
+    sessionId: textOf(message.sessionId),
+    seqNo:
+      typeof message.seqNo === "number"
+        ? message.seqNo
+        : typeof message.eventSequence === "number"
+          ? message.eventSequence
+          : undefined,
+    name: textOf(message.name),
+    tool: textOf(message.tool),
+    status: textOf(message.status),
+    phase: textOf(message.phase),
+  };
+}

package/dist/src/web-ui/app/lib/session-composer-queue.d.ts

@@ -0,0 +1,76 @@
+export interface SessionComposerQueueScope {
+  environmentId: string;
+  sessionId: string;
+}
+
+export type SessionComposerAttachmentRef = Record<string, unknown>;
+export type SessionComposerModelPreference = Record<string, unknown>;
+
+export interface SessionComposerQueueItem {
+  waitForRequestId: string;
+  text: string;
+  attachments: SessionComposerAttachmentRef[];
+  agentMode: string;
+  toolPermissionMode: string;
+  modelPreference: SessionComposerModelPreference | null;
+}
+
+export interface SessionComposerQueueItemInput {
+  waitForRequestId: string;
+  text: string;
+  attachments: SessionComposerAttachmentRef[];
+  agentMode: string;
+  toolPermissionMode: string;
+  modelPreference?: SessionComposerModelPreference | null;
+}
+
+export interface SessionComposerQueueStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+export interface ReleasedSessionComposerQueueItem {
+  item: SessionComposerQueueItem;
+  releaseToken: string;
+}
+
+export interface SessionComposerQueue {
+  enqueue(
+    scope: SessionComposerQueueScope,
+    item: SessionComposerQueueItemInput,
+  ): SessionComposerQueueItem;
+  list(scope: SessionComposerQueueScope): SessionComposerQueueItem[];
+  peek(scope: SessionComposerQueueScope): SessionComposerQueueItem | null;
+  getBlockedRelease(
+    scope: SessionComposerQueueScope,
+  ): ReleasedSessionComposerQueueItem | null;
+  updateBlockedRelease(
+    scope: SessionComposerQueueScope,
+    releaseToken: string,
+    item: SessionComposerQueueItemInput,
+  ): boolean;
+  releaseForTerminal(
+    scope: SessionComposerQueueScope,
+    terminalRequestId: string,
+  ): ReleasedSessionComposerQueueItem | null;
+  bindReleasedSuccess(
+    scope: SessionComposerQueueScope,
+    releaseToken: string,
+    newRequestId: string,
+  ): boolean;
+  rebindBlocked(
+    scope: SessionComposerQueueScope,
+    newRequestId: string,
+  ): boolean;
+}
+
+export interface CreateSessionComposerQueueOptions {
+  storage?: SessionComposerQueueStorage;
+  storageKey?: string;
+}
+
+export declare const SESSION_COMPOSER_QUEUE_STORAGE_KEY: string;
+
+export declare function createSessionComposerQueue(
+  options?: CreateSessionComposerQueueOptions,
+): SessionComposerQueue;

package/dist/src/web-ui/app/lib/session-composer-queue.js

@@ -0,0 +1,318 @@
+export const SESSION_COMPOSER_QUEUE_STORAGE_KEY =
+  "abot-web.sessionComposerQueue.v1";
+
+const STORAGE_VERSION = 1;
+let fallbackReleaseTokenSequence = 0;
+
+function emptyStore() {
+  return { version: STORAGE_VERSION, queues: [] };
+}
+
+function isRecord(value) {
+  return Boolean(
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype,
+  );
+}
+
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+
+function isJsonValue(value, depth = 0) {
+  if (depth > 32) return false;
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean"
+  ) {
+    return true;
+  }
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) {
+    return value.every((item) => isJsonValue(item, depth + 1));
+  }
+  if (!isRecord(value)) return false;
+  return Object.values(value).every((item) => isJsonValue(item, depth + 1));
+}
+
+function isAttachmentRef(value) {
+  return isRecord(value) && isJsonValue(value);
+}
+
+function isQueueItem(value) {
+  return Boolean(
+    isRecord(value) &&
+    isNonEmptyString(value.waitForRequestId) &&
+    typeof value.text === "string" &&
+    Array.isArray(value.attachments) &&
+    value.attachments.every(isAttachmentRef) &&
+    isNonEmptyString(value.agentMode) &&
+    isNonEmptyString(value.toolPermissionMode) &&
+    (value.modelPreference === null ||
+      (isRecord(value.modelPreference) && isJsonValue(value.modelPreference))),
+  );
+}
+
+function isQueueRecord(value) {
+  const blockedReleaseItem = value?.blockedReleaseItem ?? null;
+  return Boolean(
+    isRecord(value) &&
+    isNonEmptyString(value.environmentId) &&
+    isNonEmptyString(value.sessionId) &&
+    (value.blockedByReleaseToken === null ||
+      isNonEmptyString(value.blockedByReleaseToken)) &&
+    (blockedReleaseItem === null || isQueueItem(blockedReleaseItem)) &&
+    (value.blockedByReleaseToken !== null || blockedReleaseItem === null) &&
+    Array.isArray(value.items) &&
+    value.items.every(isQueueItem) &&
+    (value.items.length > 0 || value.blockedByReleaseToken !== null),
+  );
+}
+
+function isPersistedStore(value) {
+  if (
+    !isRecord(value) ||
+    value.version !== STORAGE_VERSION ||
+    !Array.isArray(value.queues) ||
+    !value.queues.every(isQueueRecord)
+  ) {
+    return false;
+  }
+  const scopes = new Set();
+  for (const queue of value.queues) {
+    const scopeKey = JSON.stringify([queue.environmentId, queue.sessionId]);
+    if (scopes.has(scopeKey)) return false;
+    scopes.add(scopeKey);
+  }
+  return true;
+}
+
+function normalizePersistedStore(store) {
+  for (const queue of store.queues) {
+    if (queue.blockedReleaseItem === undefined) {
+      queue.blockedReleaseItem = null;
+    }
+  }
+  return store;
+}
+
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function snapshotQueueItem(item) {
+  const snapshot = {
+    waitForRequestId: item?.waitForRequestId,
+    text: item?.text,
+    attachments: item?.attachments,
+    agentMode: item?.agentMode,
+    toolPermissionMode: item?.toolPermissionMode,
+    modelPreference: item?.modelPreference ?? null,
+  };
+  if (!isQueueItem(snapshot)) {
+    throw new TypeError("Invalid session composer queue item");
+  }
+  return cloneJson(snapshot);
+}
+
+function validateScope(scope) {
+  if (
+    !isRecord(scope) ||
+    !isNonEmptyString(scope.environmentId) ||
+    !isNonEmptyString(scope.sessionId)
+  ) {
+    throw new TypeError("Queue scope requires environmentId and sessionId");
+  }
+  return {
+    environmentId: scope.environmentId,
+    sessionId: scope.sessionId,
+  };
+}
+
+function findQueue(store, scope) {
+  return store.queues.find(
+    (queue) =>
+      queue.environmentId === scope.environmentId &&
+      queue.sessionId === scope.sessionId,
+  );
+}
+
+function createReleaseToken() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  fallbackReleaseTokenSequence += 1;
+  return `release-${Date.now().toString(36)}-${fallbackReleaseTokenSequence.toString(36)}`;
+}
+
+export function createSessionComposerQueue({
+  storage = globalThis.localStorage,
+  storageKey = SESSION_COMPOSER_QUEUE_STORAGE_KEY,
+} = {}) {
+  if (
+    !storage ||
+    typeof storage.getItem !== "function" ||
+    typeof storage.setItem !== "function"
+  ) {
+    throw new TypeError("Queue storage requires getItem and setItem");
+  }
+  if (!isNonEmptyString(storageKey)) {
+    throw new TypeError("Queue storageKey must be a non-empty string");
+  }
+
+  function readStore() {
+    try {
+      const raw = storage.getItem(storageKey);
+      if (raw === null) return emptyStore();
+      if (typeof raw !== "string") return emptyStore();
+      const parsed = JSON.parse(raw);
+      return isPersistedStore(parsed)
+        ? normalizePersistedStore(parsed)
+        : emptyStore();
+    } catch {
+      return emptyStore();
+    }
+  }
+
+  function writeStore(store) {
+    storage.setItem(storageKey, JSON.stringify(store));
+  }
+
+  function enqueue(scopeInput, itemInput) {
+    const scope = validateScope(scopeInput);
+    const item = snapshotQueueItem(itemInput);
+    const store = readStore();
+    let queue = findQueue(store, scope);
+    if (!queue) {
+      queue = {
+        ...scope,
+        blockedByReleaseToken: null,
+        blockedReleaseItem: null,
+        items: [],
+      };
+      store.queues.push(queue);
+    }
+    queue.items.push(item);
+    writeStore(store);
+    return cloneJson(item);
+  }
+
+  function list(scopeInput) {
+    const scope = validateScope(scopeInput);
+    const queue = findQueue(readStore(), scope);
+    return queue ? cloneJson(queue.items) : [];
+  }
+
+  function peek(scopeInput) {
+    return list(scopeInput)[0] ?? null;
+  }
+
+  function getBlockedRelease(scopeInput) {
+    const scope = validateScope(scopeInput);
+    const queue = findQueue(readStore(), scope);
+    if (
+      !queue ||
+      queue.blockedByReleaseToken === null ||
+      queue.blockedReleaseItem === null
+    ) {
+      return null;
+    }
+    return {
+      releaseToken: queue.blockedByReleaseToken,
+      item: cloneJson(queue.blockedReleaseItem),
+    };
+  }
+
+  function updateBlockedRelease(scopeInput, releaseToken, itemInput) {
+    const scope = validateScope(scopeInput);
+    if (!isNonEmptyString(releaseToken)) return false;
+    const item = snapshotQueueItem(itemInput);
+    const store = readStore();
+    const queue = findQueue(store, scope);
+    if (
+      !queue ||
+      queue.blockedByReleaseToken !== releaseToken ||
+      queue.blockedReleaseItem === null
+    ) {
+      return false;
+    }
+    queue.blockedReleaseItem = item;
+    writeStore(store);
+    return true;
+  }
+
+  function releaseForTerminal(scopeInput, terminalRequestId) {
+    const scope = validateScope(scopeInput);
+    if (!isNonEmptyString(terminalRequestId)) return null;
+    const store = readStore();
+    const queue = findQueue(store, scope);
+    if (
+      !queue ||
+      queue.blockedByReleaseToken !== null ||
+      queue.items[0]?.waitForRequestId !== terminalRequestId
+    ) {
+      return null;
+    }
+
+    const [item] = queue.items.splice(0, 1);
+    const releaseToken = createReleaseToken();
+    queue.blockedByReleaseToken = releaseToken;
+    queue.blockedReleaseItem = item;
+    writeStore(store);
+    return { item: cloneJson(item), releaseToken };
+  }
+
+  function bindReleasedSuccess(scopeInput, releaseToken, newRequestId) {
+    const scope = validateScope(scopeInput);
+    if (!isNonEmptyString(releaseToken) || !isNonEmptyString(newRequestId)) {
+      return false;
+    }
+    const store = readStore();
+    const queue = findQueue(store, scope);
+    if (!queue || queue.blockedByReleaseToken !== releaseToken) return false;
+
+    if (queue.items[0]) {
+      queue.items[0].waitForRequestId = newRequestId;
+    }
+    queue.blockedByReleaseToken = null;
+    queue.blockedReleaseItem = null;
+    if (queue.items.length === 0) {
+      store.queues = store.queues.filter((candidate) => candidate !== queue);
+    }
+    writeStore(store);
+    return true;
+  }
+
+  function rebindBlocked(scopeInput, newRequestId) {
+    const scope = validateScope(scopeInput);
+    if (!isNonEmptyString(newRequestId)) return false;
+    const store = readStore();
+    const queue = findQueue(store, scope);
+    if (!queue || queue.blockedByReleaseToken === null) return false;
+
+    if (queue.items[0]) {
+      queue.items[0].waitForRequestId = newRequestId;
+    }
+    queue.blockedByReleaseToken = null;
+    queue.blockedReleaseItem = null;
+    if (queue.items.length === 0) {
+      store.queues = store.queues.filter((candidate) => candidate !== queue);
+    }
+    writeStore(store);
+    return true;
+  }
+
+  return {
+    enqueue,
+    list,
+    peek,
+    getBlockedRelease,
+    updateBlockedRelease,
+    releaseForTerminal,
+    bindReleasedSuccess,
+    rebindBlocked,
+  };
+}

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

@@ -0,0 +1,13 @@
+export declare function textOf(value: unknown, fallback?: string): string;
+export declare function shortId(id: unknown): string;
+export declare function formatTime(value: unknown): string;
+export declare function hasRtlText(value: unknown): boolean;
+export declare function applyTextDirection(
+  element: HTMLElement,
+  value: unknown,
+): void;
+export declare function createWebSessionId(): string;
+export declare function escapeHtml(value: unknown): string;
+export declare function escapeAttribute(value: unknown): string;
+export declare function safeLinkHref(value: unknown, baseHref?: string): string;
+export declare function renderMarkdown(raw: unknown): string;