@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -2,10 +2,16 @@ import type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
 
 type PreferenceMap = Record<string, unknown>;
 type SessionModeMap = Record<string, Record<string, unknown>>;
+type SessionSidebarPreferences = {
+  archivedSessionIds: string[];
+  orderedSessionIds: string[];
+};
 
 export declare function createClientPreferences(storage: Pick<
   Storage, "getItem" | "setItem" | "removeItem"
 >): {
+  loadSessionSidebar(environmentId: string): SessionSidebarPreferences;
+  saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void;
   loadPinnedSessions(): string[];
   savePinnedSessions(sessionIds: readonly string[]): void;
   loadSessionModes(normalize: (value: unknown) => ToolPermissionMode): SessionModeMap;

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

@@ -1,3 +1,5 @@
+import { createSessionSidebarPreferences } from "./session-sidebar-preferences.js";
+
 const storageKeys = {
   environmentId: "abot-web.environmentId",
   pinnedSessions: "abot-web.pinnedSessions",
@@ -34,6 +36,7 @@ function restoreSessionMode(value, normalizeToolPermissionMode) {
 
 export function createClientPreferences(storage) {
   return {
+    ...createSessionSidebarPreferences(storage),
     loadPinnedSessions() {
       try {
         const raw = storage.getItem(storageKeys.pinnedSessions);

package/dist/src/web-ui/app/services/home-guidance-preferences.js

@@ -0,0 +1,47 @@
+/** Browser-local review receipts only. Memory content never goes into storage. */
+export function createHomeGuidancePreferences(storage) {
+  const key = (environment) => `abot-web.homeGuidance.${encodeURIComponent(environment)}`;
+  const volatile = new Map();
+  function read(environment) {
+    if (volatile.has(environment)) return volatile.get(environment);
+    try {
+      const value = JSON.parse(storage?.getItem(key(environment)) || "null");
+      if (value && typeof value === "object" && !Array.isArray(value)) return {
+        offeredOn: typeof value.offeredOn === "string" ? value.offeredOn : "",
+        dismissed: Array.isArray(value.dismissed) ? value.dismissed.filter((id) => typeof id === "string").slice(-8) : [],
+        reviewed: Array.isArray(value.reviewed) ? value.reviewed.filter((id) => typeof id === "string").slice(-200) : [],
+      };
+    } catch { /* Browser preferences may be unavailable. */ }
+    return volatile.get(environment) || {};
+  }
+  function save(environment, patch) {
+    const value = { ...read(environment), ...patch };
+    try {
+      if (!storage) throw new Error("Storage unavailable");
+      storage.setItem(key(environment), JSON.stringify(value));
+      volatile.delete(environment);
+    } catch { volatile.set(environment, value); }
+  }
+  return {
+    dismissed: (environment) => read(environment).dismissed || [],
+    dismiss(environment, id) {
+      const dismissed = new Set(read(environment).dismissed || []);
+      dismissed.add(id);
+      save(environment, { dismissed: [...dismissed].slice(-8) });
+    },
+    wasOffered: (environment, day) => read(environment).offeredOn === day,
+    markOffered: (environment, day) => save(environment, { offeredOn: day }),
+    hasReviewed(environment, record) {
+      return (read(environment).reviewed || []).includes(`${record.id}:${record.updatedAt}`);
+    },
+    markReviewed(environment, record) {
+      const receipt = `${record.id}:${record.updatedAt}`;
+      const reviewed = (read(environment).reviewed || []).filter((id) => id !== receipt);
+      save(environment, { reviewed: [...reviewed, receipt].slice(-200) });
+    },
+  };
+}
+
+export function localReviewDay(date = new Date()) {
+  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+}

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

@@ -0,0 +1,36 @@
+import type { AutomationRevision, OperationRef } from "../../../../runtime/automations/definition-contracts.js";
+
+export type AutomationDraftResponse = Readonly<{
+  draft: Readonly<{ automationId: string; revision: number; definition: AutomationRevision; archivedAt?: string }>;
+  grant?: Record<string, unknown> | null;
+  validation?: Record<string, unknown> | null;
+}>;
+
+export type AutomationRequests = Readonly<{
+  supportsAutomations(): boolean;
+  listAutomations(environmentId?: string): Promise<{ automations: Record<string, unknown>[] }>;
+  createAutomation(environmentId?: string, templateId?: string): Promise<AutomationDraftResponse>;
+  getAutomationDraft(automationId: string, environmentId?: string): Promise<AutomationDraftResponse>;
+  mutateAutomationDraft(automationId: string, expectedRevision: number, mutation: Record<string, unknown>, environmentId?: string): Promise<AutomationDraftResponse>;
+  deleteAutomationDraft(automationId: string, expectedRevision: number, environmentId?: string): Promise<{ ok: true }>;
+  archiveAutomation(automationId: string, expectedRevision: number, environmentId?: string): Promise<AutomationDraftResponse>;
+  restoreAutomation(automationId: string, expectedRevision: number, environmentId?: string): Promise<AutomationDraftResponse>;
+  saveAutomationAgent(automationId: string, nodeId: string, expectedRevision: number, environmentId?: string): Promise<Record<string, unknown>>;
+  validateAutomation(automationId: string, environmentId?: string): Promise<Record<string, unknown>>;
+  publishAutomation(automationId: string, expectedRevision: number, environmentId?: string): Promise<Record<string, unknown>>;
+  setAutomationActive(automationId: string, active: boolean, environmentId?: string): Promise<Record<string, unknown>>;
+  setAutomationPermission(automationId: string, input: { expectedGrantRevision: number; mode: "full_access" | "full_plus"; operations: OperationRef[] }, environmentId?: string): Promise<Record<string, unknown>>;
+  getAutomationCatalog(automationId: string, environmentId?: string): Promise<Record<string, unknown>>;
+  startAutomationRun(automationId: string, idempotencyKey: string, environmentId?: string): Promise<Record<string, unknown>>;
+  listAutomationRuns(automationId: string, environmentId?: string): Promise<Record<string, unknown>>;
+  getAutomationRun(runId: string, environmentId?: string): Promise<Record<string, unknown>>;
+  getAutomationStepEvidence(runId: string, nodeId: string, environmentId?: string, full?: boolean): Promise<Record<string, unknown>>;
+  stopAutomationRun(runId: string, environmentId?: string): Promise<Record<string, unknown>>;
+  rerunAutomationRun(runId: string, idempotencyKey: string, environmentId?: string): Promise<Record<string, unknown>>;
+}>;
+
+export declare function createAutomationRequests(options: {
+  requestApi(path: string, options?: RequestInit): Promise<Record<string, unknown>>;
+  getEnvironmentId(): string;
+  getConfig(): Record<string, unknown> | null;
+}): AutomationRequests;

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

@@ -0,0 +1,63 @@
+export function createAutomationRequests({ requestApi, getEnvironmentId, getConfig }) {
+  const supportsAutomations = () => getConfig()?.backend === "runtime";
+  const path = (suffix = "", environmentId = getEnvironmentId()) =>
+    `/automations${suffix}?environment=${encodeURIComponent(environmentId)}`;
+  const runPath = (runId, environmentId = getEnvironmentId()) =>
+    `/automation-runs/${encodeURIComponent(runId)}?environment=${encodeURIComponent(environmentId)}`;
+  const runActionPath = (runId, action, environmentId = getEnvironmentId()) =>
+    `/automation-runs/${encodeURIComponent(runId)}/${action}?environment=${encodeURIComponent(environmentId)}`;
+  const requestAutomation = (url, options) => {
+    if (!supportsAutomations())
+      throw new Error("Automations require the local Runtime backend.");
+    return requestApi(url, options);
+  };
+  const post = (url, input) => requestAutomation(url, {
+    method: "POST", body: JSON.stringify(input),
+  });
+  return {
+    supportsAutomations,
+    listAutomations: (environmentId) => requestAutomation(path("", environmentId)),
+    createAutomation: (environmentId, templateId) => post(path("", environmentId),
+      templateId ? { templateId } : {}),
+    getAutomationDraft: (automationId, environmentId) =>
+      requestAutomation(path(`/${encodeURIComponent(automationId)}/draft`, environmentId)),
+    mutateAutomationDraft: (automationId, expectedRevision, mutation, environmentId) =>
+      requestAutomation(path(`/${encodeURIComponent(automationId)}/draft`, environmentId), {
+        method: "PATCH", body: JSON.stringify({ expectedRevision, mutation }),
+      }),
+    deleteAutomationDraft: (automationId, expectedRevision, environmentId) =>
+      requestAutomation(path(`/${encodeURIComponent(automationId)}/draft`, environmentId), {
+        method: "DELETE", body: JSON.stringify({ expectedRevision }),
+      }),
+    saveAutomationAgent: (automationId, nodeId, expectedRevision, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/agents`, environmentId), {
+        nodeId, expectedRevision,
+      }),
+    validateAutomation: (automationId, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/validate`, environmentId), {}),
+    publishAutomation: (automationId, expectedRevision, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/publish`, environmentId), { expectedRevision }),
+    setAutomationActive: (automationId, active, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/${active ? "activate" : "pause"}`, environmentId), {}),
+    archiveAutomation: (automationId, expectedRevision, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/archive`, environmentId), { expectedRevision }),
+    restoreAutomation: (automationId, expectedRevision, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/restore`, environmentId), { expectedRevision }),
+    setAutomationPermission: (automationId, permission, environmentId) =>
+      requestAutomation(path(`/${encodeURIComponent(automationId)}/permission`, environmentId), {
+        method: "PUT", body: JSON.stringify(permission),
+      }),
+    getAutomationCatalog: (automationId, environmentId) =>
+      requestAutomation(`${path("/catalog", environmentId)}&automation=${encodeURIComponent(automationId)}`),
+    startAutomationRun: (automationId, idempotencyKey, environmentId) =>
+      post(path(`/${encodeURIComponent(automationId)}/run`, environmentId), { idempotencyKey }),
+    listAutomationRuns: (automationId, environmentId) =>
+      requestAutomation(path(`/${encodeURIComponent(automationId)}/runs`, environmentId)),
+    getAutomationRun: (runId, environmentId) => requestAutomation(runPath(runId, environmentId)),
+    getAutomationStepEvidence: (runId, nodeId, environmentId, full = false) => requestAutomation(
+      `/automation-runs/${encodeURIComponent(runId)}/steps/${encodeURIComponent(nodeId)}?environment=${encodeURIComponent(environmentId || getEnvironmentId())}${full ? "&full=1" : ""}`),
+    stopAutomationRun: (runId, environmentId) => post(runActionPath(runId, "stop", environmentId), {}),
+    rerunAutomationRun: (runId, idempotencyKey, environmentId) =>
+      post(runActionPath(runId, "rerun", environmentId), { idempotencyKey, confirmed: true }),
+  };
+}

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

@@ -27,6 +27,12 @@ export function createConfigurationRequests({ requestApi, environmentQuery }) {
         body: JSON.stringify(input),
       });
     },
+    removeRuntimeModel(input, environmentId) {
+      return requestApi(scoped("/runtime/config/models", environmentId), {
+        method: "DELETE",
+        body: JSON.stringify(input),
+      });
+    },
     getRuntimePlugins(environmentId) {
       return requestApi(scoped("/runtime/plugins", environmentId));
     },

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

@@ -0,0 +1,63 @@
+export function createPassiveLearningRequests({
+  requestApi,
+  getEnvironmentId,
+  environmentQuery,
+}) {
+  const environmentPath = (suffix, environmentId) =>
+    `/runtime/learning${suffix}?environment=${environmentQuery(environmentId)}`;
+
+  return Object.freeze({
+    loadPassiveLearning(environmentId = getEnvironmentId(), { signal } = {}) {
+      return requestApi(
+        environmentPath("", environmentId),
+        signal ? { signal } : {},
+      );
+    },
+    configurePassiveLearning(input, environmentId = getEnvironmentId()) {
+      return requestApi("/runtime/learning", {
+        method: "PUT",
+        body: JSON.stringify({ environment: environmentId, ...input }),
+      });
+    },
+    restartPassiveLearningCollection(environmentId = getEnvironmentId()) {
+      return requestApi(environmentPath("/collection/restart", environmentId), {
+        method: "POST",
+        body: "{}",
+      });
+    },
+    clearPassiveLearningPending(environmentId = getEnvironmentId()) {
+      return requestApi(environmentPath("/pending", environmentId), {
+        method: "DELETE",
+        body: "{}",
+      });
+    },
+    listPassiveLearningCandidates(
+      environmentId = getEnvironmentId(),
+      { signal } = {},
+    ) {
+      return requestApi(
+        environmentPath("/candidates", environmentId),
+        signal ? { signal } : {},
+      );
+    },
+    listPassiveLearningBatches(
+      environmentId = getEnvironmentId(),
+      { signal } = {},
+    ) {
+      return requestApi(
+        environmentPath("/batches", environmentId),
+        signal ? { signal } : {},
+      );
+    },
+    loadPassiveLearningBatch(
+      id,
+      environmentId = getEnvironmentId(),
+      { signal } = {},
+    ) {
+      return requestApi(
+        environmentPath(`/batches/${encodeURIComponent(id)}`, environmentId),
+        signal ? { signal } : {},
+      );
+    },
+  });
+}

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

@@ -51,10 +51,11 @@ export function createLongTermMemoryRequests({
       environmentId = getEnvironmentId(),
       limit = 20,
       offset = 0,
+      origin,
       signal,
     } = {}) {
       return requestApi(
-        memoryRecordsPath({ environmentId, limit, offset }),
+        memoryRecordsPath({ environmentId, limit, offset, origin }),
         signal ? { signal } : {},
       );
     },
@@ -112,13 +113,15 @@ export function createLongTermMemoryRequests({
   });
 }
 
-function memoryRecordsPath({ environmentId, limit, offset, query }) {
+function memoryRecordsPath({ environmentId, limit, offset, query, origin }) {
   const params = new URLSearchParams({
     environment: environmentId,
     limit: String(limit),
     offset: String(offset),
   });
   if (query !== undefined) params.set("q", query);
+  if (query === undefined && origin === "passive_observation")
+    params.set("origin", origin);
   const route =
     query === undefined
       ? "/runtime/memory/records"

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

@@ -0,0 +1,30 @@
+import type {
+  NotificationDesktopState,
+  NotificationListQuery,
+  NotificationPage,
+  NotificationPreferences,
+  NotificationReadChange,
+  NotificationReadResult,
+} from "../../../notifications/contracts.js";
+
+export interface NotificationRequests {
+  supportsNotifications(): boolean;
+  listNotifications(
+    environmentId?: string,
+    page?: NotificationListQuery,
+  ): Promise<{ ok: true; desktop: NotificationDesktopState } & NotificationPage>;
+  markNotificationsRead(
+    input: NotificationReadChange,
+    environmentId?: string,
+  ): Promise<{ ok: true } & NotificationReadResult>;
+  saveNotificationPreferences(
+    input: NotificationPreferences,
+    environmentId?: string,
+  ): Promise<{ ok: true; preferences: NotificationPreferences }>;
+}
+
+export function createNotificationRequests(options: {
+  requestApi(path: string, options?: RequestInit): Promise<unknown>;
+  getConfig(): Record<string, unknown> | null;
+  getEnvironmentId(): string;
+}): NotificationRequests;

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

@@ -0,0 +1,27 @@
+export function createNotificationRequests({ requestApi, getConfig, getEnvironmentId }) {
+  const supportsNotifications = () => getConfig()?.backend === "runtime";
+  function requireNotifications() {
+    if (!supportsNotifications()) throw new Error("Notifications are unavailable with this backend.");
+  }
+  return {
+    supportsNotifications,
+    listNotifications(environmentId = getEnvironmentId(), { before, limit = 50 } = {}) {
+      requireNotifications();
+      const query = new URLSearchParams({ environment: environmentId, limit: String(limit) });
+      if (before) query.set("before", before);
+      return requestApi(`/notifications?${query}`);
+    },
+    markNotificationsRead(input, environmentId = getEnvironmentId()) {
+      requireNotifications();
+      return requestApi("/notifications/read", {
+        method: "POST", body: JSON.stringify({ ...input, environment: environmentId }),
+      });
+    },
+    saveNotificationPreferences(input, environmentId = getEnvironmentId()) {
+      requireNotifications();
+      return requestApi("/notifications/preferences", {
+        method: "PUT", body: JSON.stringify({ ...input, environment: environmentId }),
+      });
+    },
+  };
+}

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

@@ -1,3 +1,5 @@
+import { toolPermissionRequestError } from "../../lib/tool-permission-mode.js";
+
 export function createScheduleRequests({
   requestApi,
   getEnvironmentId,
@@ -7,8 +9,15 @@ export function createScheduleRequests({
   const requestSchedules = async (url, options) => {
     if (!supportsSchedules())
       throw new Error("Schedules require the local Runtime backend.");
+    const input = options?.body ? JSON.parse(options.body) : null;
+    requireSchedulePermission(input);
     return requestApi(url, options);
   };
+  function requireSchedulePermission(input) {
+    if (input?.toolPermissionMode === undefined) return;
+    const error = toolPermissionRequestError(input.toolPermissionMode, getConfig());
+    if (error) throw new Error(error.message);
+  }
   const path = (suffix = "", environmentId = getEnvironmentId()) =>
     `/schedules${suffix}?environment=${encodeURIComponent(environmentId)}`;
   const runPagePath = (resourceSuffix, environmentId, page = {}) => {

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

@@ -0,0 +1,22 @@
+export interface SparkChatReadState {
+  unreadCount: number;
+  unreadMessageIds: Array<string | number>;
+  readRevision: number;
+  readGeneration: string;
+  hasUnread: boolean;
+}
+export interface SparkChatSnapshot {
+  ok: boolean;
+  sessionId: string;
+  toolPermissionMode: "ask" | "full_access" | "full_plus";
+  modelProfileId: string | null;
+  snapshot: { messages: Array<Record<string, unknown>>; requests?: Array<Record<string, unknown>> };
+  readState: SparkChatReadState;
+}
+export interface SparkChatRequests {
+  supportsSparkChat(): boolean;
+  loadSparkChat(environmentId?: string): Promise<SparkChatSnapshot>;
+  configureSparkChat(input: { toolPermissionMode: "ask" | "full_access" | "full_plus" }, environmentId?: string): Promise<SparkChatSnapshot>;
+  createSparkHandoffSession(input: { message: { id: string | number; createdAt: number; requestId: string | null } }, environmentId?: string): Promise<{ ok: boolean; sessionId: string }>;
+  markSparkMessagesRead(input: { visibleMessageIds: Array<string | number>; visibleMessages: Array<{ id: string | number; createdAt: number; requestId: string | null }>; readGeneration: string }, environmentId?: string): Promise<{ ok: boolean; readState: SparkChatReadState }>;
+}

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

@@ -0,0 +1,29 @@
+export function createSparkChatRequests({ requestApi, getEnvironmentId, getConfig }) {
+  const supportsSparkChat = () => getConfig()?.backend === "runtime";
+  function path(environmentId) {
+    if (!supportsSparkChat()) throw new Error("SPARK chat is unavailable with this backend.");
+    return `/runtime/spark/chat?${new URLSearchParams({ environment: environmentId })}`;
+  }
+  return {
+    supportsSparkChat,
+    loadSparkChat(environmentId = getEnvironmentId()) {
+      return requestApi(path(environmentId));
+    },
+    configureSparkChat(input, environmentId = getEnvironmentId()) {
+      return requestApi(path(environmentId), {
+        method: "PUT", body: JSON.stringify(input),
+      });
+    },
+    createSparkHandoffSession(input, environmentId = getEnvironmentId()) {
+      return requestApi(path(environmentId).replace("?", "/sessions?"), {
+        method: "POST", body: JSON.stringify(input),
+      });
+    },
+    markSparkMessagesRead({ visibleMessageIds, visibleMessages, readGeneration }, environmentId = getEnvironmentId()) {
+      const url = path(environmentId).replace("?", "/read?");
+      return requestApi(url, {
+        method: "POST", body: JSON.stringify({ visibleMessageIds, visibleMessages, readGeneration }),
+      });
+    },
+  };
+}

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

@@ -1,5 +1,5 @@
 /** Pairing is shared by this ABot installation, independent of environments. */
-export function createSystemHostRequests({ requestApi, getConfig }) {
+export function createSystemHostRequests({ requestApi, getConfig, getEnvironmentId }) {
   const supportsSystemHostConnection = () => getConfig()?.backend === "runtime";
 
   async function requestSystemHost(path = "", options) {
@@ -13,11 +13,15 @@ export function createSystemHostRequests({ requestApi, getConfig }) {
 
   return {
     supportsSystemHostConnection,
-    getSystemHostConnection: () => requestSystemHost(),
-    downloadSystemHostSetup: (platform) =>
+    getSystemHostConnection: () => requestSystemHost(`?environment=${encodeURIComponent(getEnvironmentId())}`),
+    requestSystemHostPermissions: (input) =>
+      requestSystemHost("/permissions", { method: "POST", body: JSON.stringify(input) }),
+    connectLocalSystemHost: () =>
+      requestSystemHost("/connect-local", { method: "POST", body: "{}" }),
+    downloadSystemHostSetup: (platform, options = {}) =>
       requestSystemHost("/setup", {
         method: "POST",
-        body: JSON.stringify({ platform }),
+        body: JSON.stringify({ platform, ...(options.purpose === "learning" ? { purpose: "learning" } : {}) }),
       }),
     createSystemHostPairing: () =>
       requestSystemHost("/pairing", { method: "POST", body: "{}" }),

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

@@ -0,0 +1,20 @@
+import type {
+  PendingWebToolApproval,
+  WebToolApprovalDecision,
+} from "../../../local-runtime/pending-tool-approvals.js";
+
+export interface ToolApprovalRequests {
+  supportsToolApprovals(): boolean;
+  listToolApprovals(
+    environmentId?: string,
+  ): Promise<{ approvals: PendingWebToolApproval[] }>;
+  decideToolApproval(
+    decision: WebToolApprovalDecision,
+  ): Promise<{ ok: true; approvalId: string }>;
+}
+
+export declare function createToolApprovalRequests(options: {
+  requestApi(path: string, options?: RequestInit): Promise<unknown>;
+  getEnvironmentId(): string;
+  getConfig(): Record<string, unknown> | null;
+}): ToolApprovalRequests;

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

@@ -0,0 +1,72 @@
+function hasScopedApproval(approval, environmentId) {
+  if (approval?.environmentId !== environmentId) return false;
+  if (typeof approval.sessionId !== "string" || !approval.sessionId)
+    return false;
+  if (typeof approval.requestId !== "string" || !approval.requestId)
+    return false;
+  if (typeof approval.approvalId !== "string" || !approval.approvalId)
+    return false;
+  if (approval.event?.name !== "tool.approval.required") return false;
+  if (approval.event.requestId !== approval.requestId) return false;
+  return approval.event.approvalId === approval.approvalId;
+}
+
+export function createToolApprovalRequests({
+  requestApi,
+  getConfig,
+  getEnvironmentId,
+}) {
+  const supportsToolApprovals = () => getConfig()?.backend === "runtime";
+
+  async function listToolApprovals(environmentId = getEnvironmentId()) {
+    if (!supportsToolApprovals())
+      throw new Error("Home approvals are unavailable.");
+    const result = await requestApi(
+      `/chat/approvals?environment=${encodeURIComponent(environmentId)}`,
+    );
+    if (!Array.isArray(result?.approvals))
+      throw new Error("Invalid approval list.");
+    if (
+      !result.approvals.every((approval) =>
+        hasScopedApproval(approval, environmentId),
+      )
+    )
+      throw new Error("Invalid approval identity.");
+    return result;
+  }
+
+  async function decideToolApproval({
+    environmentId,
+    sessionId,
+    requestId,
+    approvalId,
+    approved,
+    generation,
+    waitId,
+    revision,
+    commandId,
+  }) {
+    if (!supportsToolApprovals())
+      throw new Error("Home approvals are unavailable.");
+    const result = await requestApi(
+      `/chat/approvals/${encodeURIComponent(approvalId)}`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          environment: environmentId,
+          sessionId,
+          requestId,
+          approved,
+          ...(waitId ? { generation, waitId, revision, commandId } : {}),
+        }),
+      },
+    );
+    if (result?.ok !== true || result.approvalId !== approvalId)
+      throw new Error(
+        "The approval decision could not be confirmed. Refresh before trying again.",
+      );
+    return result;
+  }
+
+  return { supportsToolApprovals, listToolApprovals, decideToolApproval };
+}