@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/shared/public-http/request-hop.js

@@ -0,0 +1,140 @@
+import { request as requestHttp, } from "node:http";
+import { request as requestHttps } from "node:https";
+import { PublicHttpError, isPublicHttpError } from "./errors.js";
+import { PUBLIC_HTTP_LIMITS } from "./limits.js";
+function buildPinnedLookup(address) {
+    return (_hostname, options, callback) => {
+        if (options.all) {
+            callback(null, [address]);
+            return;
+        }
+        callback(null, address.address, address.family);
+    };
+}
+function contentLength(headers) {
+    const raw = headers["content-length"];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (typeof value !== "string" || !/^\d+$/u.test(value))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+function readBoundedBody(response, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let bytesRead = 0;
+        let settled = false;
+        const finish = (partialContent) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(Object.freeze({
+                body: Buffer.concat(chunks, bytesRead),
+                partialContent,
+            }));
+        };
+        response.on("data", (rawChunk) => {
+            if (settled)
+                return;
+            const chunk = Buffer.isBuffer(rawChunk)
+                ? rawChunk
+                : Buffer.from(rawChunk);
+            const remaining = maxBytes - bytesRead;
+            if (chunk.byteLength > remaining) {
+                if (remaining > 0) {
+                    chunks.push(chunk.subarray(0, remaining));
+                    bytesRead += remaining;
+                }
+                finish(true);
+                response.destroy();
+                return;
+            }
+            chunks.push(chunk);
+            bytesRead += chunk.byteLength;
+        });
+        response.once("end", () => finish(false));
+        response.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+        response.once("aborted", () => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new PublicHttpError("web_response_invalid", "The upstream response ended before completion."));
+        });
+    });
+}
+export const requestPinnedHop = async (params) => {
+    if (params.abortSignal?.aborted) {
+        throw new PublicHttpError("web_request_aborted", "The web request was aborted.");
+    }
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let timedOut = false;
+        const requestOptions = {
+            protocol: params.url.protocol,
+            hostname: params.url.hostname.replace(/^\[|\]$/gu, ""),
+            port: params.url.port || undefined,
+            path: `${params.url.pathname}${params.url.search}`,
+            method: "GET",
+            headers: params.headers,
+            lookup: buildPinnedLookup(params.address),
+            agent: false,
+            maxHeaderSize: PUBLIC_HTTP_LIMITS.responseHeaderBytes,
+        };
+        const requestFunction = params.url.protocol === "https:" ? requestHttps : requestHttp;
+        const request = requestFunction(requestOptions, async (response) => {
+            try {
+                const declaredLength = contentLength(response.headers);
+                const body = await readBoundedBody(response, params.maxBytes);
+                if (settled)
+                    return;
+                settled = true;
+                resolve(Object.freeze({
+                    status: response.statusCode ?? 0,
+                    headers: response.headers,
+                    body: body.body,
+                    bytesRead: body.body.byteLength,
+                    partialContent: body.partialContent ||
+                        (declaredLength !== undefined &&
+                            declaredLength > params.maxBytes),
+                }));
+            }
+            catch (error) {
+                if (settled)
+                    return;
+                settled = true;
+                reject(error);
+            }
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            request.destroy(new PublicHttpError("web_request_timed_out", "The upstream web request timed out."));
+        }, params.timeoutMs);
+        timeout.unref?.();
+        const onAbort = () => request.destroy(new PublicHttpError("web_request_aborted", "The web request was aborted."));
+        params.abortSignal?.addEventListener("abort", onAbort, { once: true });
+        request.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (isPublicHttpError(error)) {
+                reject(error);
+            }
+            else if (timedOut) {
+                reject(new PublicHttpError("web_request_timed_out", "The upstream web request timed out."));
+            }
+            else {
+                reject(new PublicHttpError("web_response_invalid", "The upstream web request failed."));
+            }
+        });
+        request.once("close", () => {
+            clearTimeout(timeout);
+            params.abortSignal?.removeEventListener("abort", onAbort);
+        });
+        request.end();
+    });
+};

package/dist/src/web-ui/app/ARCHITECTURE.md

@@ -17,7 +17,7 @@ Dependencies flow in one direction:
 
 Controllers and components communicate through injected callbacks or values. They must not reach back into `app.js`; services must not depend on controllers or presentation code.
 
-`workspace-shell.js` is the single owner of workspace navigation. It owns the active Chat or Config workspace, responsive Conversations visibility, focus restoration, Escape handling, backdrop state, and related ARIA attributes. `conversation-sidebar-layout.js` resolves the sidebar presentation policy; `operations-section.js` owns the internal Runtime, Logs, and Health tabs within Configuration. These components must not own session data, request state, or Runtime transport.
+`workspace-shell.js` is the single owner of workspace navigation. It owns the active Home, Chat, Schedules or Config workspace, responsive Conversations visibility, focus restoration, Escape handling, backdrop state, and related ARIA attributes. `conversation-sidebar-layout.js` resolves the sidebar presentation policy; `operations-section.js` owns the internal Runtime, Logs, and Health tabs within Configuration. These components must not own session data, request state, or Runtime transport.
 
 `conversation-activity.js` owns only request-scoped activity presentation. `realtime-event-controller.js` preserves sequence authority, associates events and progress with their exact `requestId`, and injects those values into the conversation view. `realtime-transport.js` only parses and transports frames; it does not reduce application state.
 
@@ -25,7 +25,28 @@ Controllers and components communicate through injected callbacks or values. The
 
 `composer-plan.js` presents the current user turn's Planner plan in a collapsed-by-default drawer above the composer. `composer-plan-model.js` selects request-linked progress from the current turn, including restored failed requests that have only a persisted user message; a new user turn hides earlier plans. Disclosure identity follows the selected request, so steering preserves expansion and list scroll; session resets clear the drawer. `task-progress.js` reduces structured plan events by request: full snapshots replace the baseline, later item changes are retained across overlapping replay, and completion counters never imply request or Reviewer success. Live events and stored replay use this same projection. Historical per-response progress remains available in Activity.
 
-Activity counts tool invocations from `tool.started` entries and their recorded multiplicities before timeline display grouping. Completion, payload, and approval events remain visible but do not add tool invocations; terminal-only history does not invent missing starts. Failure-event counts retain their existing meaning.
+Activity counts tool invocations from `tool.started` entries and their recorded multiplicities before timeline display grouping. Completion, payload, and approval events contribute to action details but do not add tool invocations; terminal-only history does not invent missing starts. Failure-event counts retain their existing meaning.
+
+Tool activity is presented as one evolving action per `(requestId, executionId)`.
+`tool-activity-event.js` retains only bounded display fields; `tool-activity-model.js`
+combines payload, approval, execution, and outcome events without guessing from
+tool names or event adjacency. `conversation-tools.js` renders compact disclosures
+inside the executing agent's card, preserving expansion and scroll across updates.
+The canonical role call supplies `executorRole` and `roleCallId`; explicit identity
+takes precedence over the currently active role, including late completions.
+Older events use the recorded role-stage association when available. Actions
+without recorded ownership appear in an explicitly unattributed card.
+Prepared input is distinguished from input sent to an executed tool. Source
+truncation and preview clipping remain separate, and an absent outcome never
+implies success. Existing uncorrelated history supplies independent outcome rows;
+unpaired legacy progress stays in the diagnostic timeline. Live and stored events
+use the same projection. Raw lifecycle events remain stored for replay and counts.
+
+Plugins may declare `eventPresentation.resultMetadata` to select bounded previews
+or scalar facts from existing tool results. This projection is evaluated only at
+the completion-event boundary: tool output, canonical evidence and model context
+are unchanged. The Web UI does not fetch a file or memory record again to recreate
+historical evidence. Passive Runtime memory remains outside tool activity.
 
 Web sources appear in a separate Activity section alongside role cards and the event timeline. `web-source-event.js` projects only successful `web_search` and `web_fetch` completions; `web-sources.js` validates bounded plugin receipts and groups them by recorded call. `conversation-sources.js` renders links and retrieval/presentation states without interpreting answer text. Source-bearing events retain their own identity before display grouping, and stored session events use the same projection as live events. Session switching clears them with the existing Activity state.
 
@@ -33,10 +54,10 @@ The optional `meta.webSources` version 1 receipt describes the final bounded **t
 
 `conversation-session-controller.js` is the single owner of the active conversation view lifecycle: normalized message identity, session switching, stored-message hydration, request-event replay, read state, active assistant placeholders, and session/request realtime subscriptions. `chat-request-controller.js` owns starting one chat request, while `composer-submit-controller.js` owns the composer's selected action and busy/error lifecycle. `tool-approval-controller.js` owns approval state and transport; `tool-approval-card.js` owns its DOM presentation.
 
-The primary information architecture is chat-first:
+The primary information architecture starts at Home:
 
 - the navigation rail is persistent;
-- Chat and Config are mutually exclusive workspaces;
+- Home, Chat, Schedules and Config are mutually exclusive workspaces;
 - Conversations is docked beside Chat from 1260 CSS pixels upward, with its own column and no modal backdrop;
 - below that width, Conversations is the only transient sheet and overlays the chat canvas;
 - Configuration always hides Conversations and uses the full content canvas;
@@ -47,6 +68,18 @@ The primary information architecture is chat-first:
 
 Panel resizing and persisted panel widths are intentionally not part of this architecture. Crossing the sidebar breakpoint closes transient drawer state and restores focus when its previous target becomes hidden.
 
+`dashboard-feature.js` composes Home presentation and data refresh. Its controller reuses the canonical conversation list and bounded scheduler run history, refreshing while Home is visible. Recent conversations retain all unread conversations and fill remaining slots with recently updated read conversations. Run activity follows the scheduler's scheduled-time ordering. Loading, failures, and empty states remain distinct.
+
+`composer-workspace-controller.js` moves the existing composer DOM between Home and Chat and isolates their draft text and attachments. `composer-surface-controller.js` routes input, rendering and attachment actions to the active surface. Both surfaces use the same attachment and submission controllers; background Chat queue work writes to its own input surface. Home submission adopts its draft into a new conversation before invoking the ordinary Chat request controller. Home navigation alone never resets or reads the active conversation. `conversation-read-state-controller.js` rechecks visible Chat, environment, session and view revision before marking persisted assistant messages read.
+
+Dashboard Job suggestions are inert data in `dashboard-job-templates.js`. They open the ordinary schedule form with editable defaults, a selected model, device time zone and a new dedicated conversation target. Only explicit Save creates state. `schedule-job-creation.ts` adapts this Web-only target into an owner-created conversation and the existing scheduler contract; it never invokes the model. Existing-conversation creation remains supported. `configuration-feature.js` owns the composition of Configuration and its memory controls. `app-bootstrap.js` owns startup ordering, environment restoration, initial loading and Home activation.
+
+Read tracking belongs only to the native Web UI backend. `session-read-state/service.ts` reads canonical session snapshots and projects unread assistant replies; `store.ts` persists the UI cursors in an environment-specific sidecar under `runtimeDir/web-ui/read-state/`. Runtime session files, model context and Runtime contracts remain unchanged. A persisted initialization timestamp treats existing history as read and tracks later replies, including newly created Job conversations. Read acknowledgements resolve only the displayed persisted assistant message or its exact completed request ID. Cursors advance monotonically and survive server restarts; invalid boundaries never acknowledge unseen replies. Browser consumers retain newer read revisions when older responses arrive late.
+
+The native conversation list uses the existing `SessionService` disk reader and canonical client-visible projections once per refresh. It avoids offset pagination over changing conversation order and avoids sending all request-event histories through the managed Runtime RPC. Only Web UI read-state sidecars are written by this projection. Clearing messages keeps a fresh read revision so subsequent unread replies can replace the previous read receipt.
+
+Read-state persistence is an optional Web UI projection. `session-read-state/availability.ts` isolates sidecar failures from listing, loading, clearing and deleting conversations. A failure returns `readStateStatus: "unavailable"` and unknown counts, preserves the sidecar for diagnosis, and leaves read acknowledgements unsuccessful. The browser keeps the last known receipt, labels unavailable tracking explicitly and resumes normal counts after a healthy list refresh. Canonical session and attachment failures remain errors. Workspace visibility is committed before change callbacks attempt to acknowledge visible messages, including drawer closure and responsive layout changes.
+
 ## Styles
 
 `styles.css` is the ordered manifest. The modules under `styles/` own:
@@ -63,3 +96,32 @@ Keep responsive overrides last and avoid moving declarations between modules wit
 ## Contract boundary
 
 Visual components may format or group events, but they never accept transport frames or construct Runtime API payloads. Realtime frame parsing belongs to `realtime-transport.js`; request sequence and terminal-state reduction belong to `realtime-event-controller.js`; endpoint construction and HTTP payload serialization belong to `runtime-web-client.js` and its feature request modules; and feature controllers own when those operations occur. Config remains explicit-save; presentation changes must never introduce autosave.
+
+
+## Core schedules
+
+`schedules-feature.js` composes the scheduler browser feature from its controller,
+transport requests and presentation. `schedules-controller.js` owns loading and
+management actions scoped to the selected environment, guards stale reads, and
+refreshes only while the workspace is active and no editor or mutation is pending.
+The full Schedules workspace shares the shell navigation and discard guards;
+its editor uses an explicit save and a saved model/mode with Full tool access.
+Unchanged timing fields are omitted from edits, preserving the original timer or
+interval anchor when only a title, prompt or model changes.
+
+`workspace-state.js` owns the single page-level loading, empty, missing or failed
+read presentation before any schedules are available. Loaded jobs and unsaved
+editors remain visible if a later request fails. `schedule-errors.js` maps service
+error reasons to display text without changing the management or domain contract.
+The schedule workspace owns its full-width alignment; it does not inherit the
+configuration page's centered child-width caps.
+
+`conversation-schedule.js` presents the persisted invocation as a compact Job/Run
+reference. Its prompt disclosure reads that canonical message's exact historical
+content; it does not fetch the current Job to reconstruct an earlier request.
+The normal assistant reply remains separate. `schedule-realtime.js` admits only
+`schedule.triggered` events with exact environment, session, request, message and
+run identity before activating the ordinary realtime request lifecycle. Duplicate
+trigger delivery cannot add another user message or reactivate a completed run.
+The scheduler page and chat card are presentation-only consumers; the runtime
+scheduler remains the sole owner of Job state and dispatch decisions.

package/dist/src/web-ui/app/app-bootstrap.js

@@ -0,0 +1,53 @@
+import { textOf } from "./lib/text-format.js";
+
+export async function bootstrapWebApp({
+  state,
+  dom,
+  preferences,
+  shell,
+  homeComposer,
+  dashboard,
+  schedules,
+  selection,
+  client,
+  bindables,
+  bindEvents,
+  renderComposer,
+  renderMessages,
+  operations,
+  configuration,
+  realtime,
+  restoreLastSession,
+}) {
+  selection.loadPreferences();
+  shell.load();
+  homeComposer.setWorkspace(shell.activeWorkspace());
+  dashboard.setActive(true);
+  for (const control of [shell, ...bindables]) control.bind();
+  bindEvents();
+  renderComposer();
+  selection.renderPermissionMode();
+  renderMessages();
+  state.config = await client.loadWebConfig();
+  schedules.refreshAvailability();
+  selection.renderEnvironmentOptions();
+  const options = selection.environmentOptions();
+  const saved = preferences.environmentId();
+  const fallback =
+    textOf(state.config.defaultEnvironmentId).trim() || options[0]?.value || "";
+  const hasSavedEnvironment = options.some((option) => option.value === saved);
+  dom.environmentSelect.value = hasSavedEnvironment ? saved : fallback;
+  preferences.saveEnvironmentId(dom.environmentSelect.value);
+  homeComposer.environmentChanged();
+  selection.renderAgentPicker();
+  realtime.connect();
+  await Promise.allSettled([
+    selection.loadModels(),
+    selection.loadAgentMode(),
+    operations.loadRuntimeStatus(),
+    operations.loadSystemHealth(),
+    configuration.load(),
+  ]);
+  await restoreLastSession();
+  dashboard.setReady();
+}

package/dist/src/web-ui/app/app-dom.js

@@ -0,0 +1,80 @@
+export function findAppDom(documentRoot = document) {
+  return {
+    app: documentRoot.getElementById("app"),
+    homeWorkspaceButton: documentRoot.getElementById("homeWorkspaceButton"),
+    homeWorkspacePanel: documentRoot.getElementById("homeWorkspacePanel"),
+    homeDashboardRoot: documentRoot.getElementById("homeDashboardRoot"),
+    chatWorkspaceButton: documentRoot.getElementById("chatWorkspaceButton"),
+    schedulesWorkspaceButton: documentRoot.getElementById(
+      "schedulesWorkspaceButton",
+    ),
+    schedulesWorkspacePanel: documentRoot.getElementById(
+      "schedulesWorkspacePanel",
+    ),
+    closeSchedulesWorkspaceButton: documentRoot.getElementById(
+      "closeSchedulesWorkspaceButton",
+    ),
+    schedulesRoot: documentRoot.getElementById("schedulesRoot"),
+    configWorkspaceButton: documentRoot.getElementById("configWorkspaceButton"),
+    chatPanel: documentRoot.querySelector(".chat-panel"),
+    sessionsPanel: documentRoot.querySelector(".sessions-panel"),
+    configWorkspacePanel: documentRoot.getElementById("configWorkspacePanel"),
+    closeConfigWorkspaceButton: documentRoot.getElementById(
+      "closeConfigWorkspaceButton",
+    ),
+    connectionLabel: documentRoot.getElementById("connectionLabel"),
+    environmentSelect: documentRoot.getElementById("environmentSelect"),
+    agentPickerButton: documentRoot.getElementById("agentPickerButton"),
+    agentPickerMenu: documentRoot.getElementById("agentPickerMenu"),
+    newSessionButton: documentRoot.getElementById("newSessionButton"),
+    refreshSessionsButton: documentRoot.getElementById("refreshSessionsButton"),
+    closeSessionsButton: documentRoot.getElementById("closeSessionsButton"),
+    sessionsToggleButton: documentRoot.getElementById("sessionsToggleButton"),
+    sessionSearchInput: documentRoot.getElementById("sessionSearchInput"),
+    sessionsCount: documentRoot.getElementById("sessionsCount"),
+    sessionsList: documentRoot.getElementById("sessionsList"),
+    sessionTitle: documentRoot.getElementById("sessionTitle"),
+    agentModeButton: documentRoot.getElementById("agentModeButton"),
+    agentModeMenu: documentRoot.getElementById("agentModeMenu"),
+    permissionModeButton: documentRoot.getElementById("permissionModeButton"),
+    permissionModeMenu: documentRoot.getElementById("permissionModeMenu"),
+    modelSelect: documentRoot.getElementById("modelSelect"),
+    modelSelectButton: documentRoot.getElementById("modelSelectButton"),
+    modelSelectValue: documentRoot.getElementById("modelSelectValue"),
+    modelSelectMenu: documentRoot.getElementById("modelSelectMenu"),
+    messagesList: documentRoot.getElementById("messagesList"),
+    runtimeSetupGuide: documentRoot.getElementById("runtimeSetupGuide"),
+    messageStatusRegion: documentRoot.getElementById("messageStatusRegion"),
+    jumpToLatestButton: documentRoot.getElementById("jumpToLatestButton"),
+    composerForm: documentRoot.getElementById("composerForm"),
+    attachmentButton: documentRoot.getElementById("attachmentButton"),
+    attachmentInput: documentRoot.getElementById("attachmentInput"),
+    attachmentPreview: documentRoot.getElementById("attachmentPreview"),
+    composerInput: documentRoot.getElementById("composerInput"),
+    composerContextWindow: documentRoot.getElementById("composerContextWindow"),
+    composerPlan: documentRoot.getElementById("composerPlan"),
+    composerSubmitControl: documentRoot.getElementById("composerSubmitControl"),
+    sendButton: documentRoot.getElementById("sendButton"),
+    sendButtonLabel: documentRoot.getElementById("sendButtonLabel"),
+    sendNextMenuButton: documentRoot.getElementById("sendNextMenuButton"),
+    sendNextMenu: documentRoot.getElementById("sendNextMenu"),
+    sendNextButton: documentRoot.getElementById("sendNextButton"),
+    refreshRuntimeButton: documentRoot.getElementById("refreshRuntimeButton"),
+    runtimeStatus: documentRoot.getElementById("runtimeStatus"),
+    refreshLogsButton: documentRoot.getElementById("refreshLogsButton"),
+    runtimeLogs: documentRoot.getElementById("runtimeLogs"),
+    refreshHealthButton: documentRoot.getElementById("refreshHealthButton"),
+    healthStatus: documentRoot.getElementById("healthStatus"),
+    refreshConfigButton: documentRoot.getElementById("refreshConfigButton"),
+    configStatus: documentRoot.getElementById("configStatus"),
+    configDashboard: documentRoot.getElementById("configDashboard"),
+    panelBackdrop: documentRoot.getElementById("panelBackdrop"),
+    toastRegion: documentRoot.getElementById("toastRegion"),
+    operationsTabButtons: [
+      ...documentRoot.querySelectorAll(".operations-tab-button"),
+    ],
+    operationsTabPages: [
+      ...documentRoot.querySelectorAll(".operations-tab-page"),
+    ],
+  };
+}