@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/web-ui/app/lib/workspace-route.js

@@ -5,6 +5,7 @@ const WORKSPACE_PATHS = Object.freeze({
   notifications: "/notifications",
   chat: "/chat",
   schedules: "/schedules",
+  automations: "/automations",
   learning: "/learning",
   memory: "/memory",
   models: "/models",
@@ -27,13 +28,17 @@ export function readWorkspaceRoute(location) {
   const workspace = path === "/config"
     ? legacyConfigurationWorkspace(requestedCategory)
     : requestedWorkspace || "home";
+  const automationRun = workspace === "chat" ? routeParameter(parameters, "automationRun") : "";
   return {
     workspace,
     environment: routeParameter(parameters, "environment"),
-    session: routeParameter(parameters, "session"),
+    session: automationRun ? "" : routeParameter(parameters, "session"),
+    automationRun,
     category: configurationCategoryForWorkspace(workspace) || "",
     tab: routeParameter(parameters, "tab"),
     job: routeParameter(parameters, "job"),
+    automation: routeParameter(parameters, "automation"),
+    run: routeParameter(parameters, "run"),
   };
 }
 
@@ -44,13 +49,19 @@ export function workspaceRouteUrl(route) {
   const path = WORKSPACE_PATHS[workspace] || WORKSPACE_PATHS.home;
   const parameters = new URLSearchParams();
   if (route.environment) parameters.set("environment", route.environment);
-  if (workspace === "chat" && route.session)
+  if (workspace === "chat" && route.automationRun)
+    parameters.set("automationRun", route.automationRun);
+  else if (workspace === "chat" && route.session)
     parameters.set("session", route.session);
   if (workspace === "config") {
     if (route.tab) parameters.set("tab", route.tab);
   }
   if (workspace === "schedules" && route.job)
     parameters.set("job", route.job);
+  if (workspace === "automations" && route.automation)
+    parameters.set("automation", route.automation);
+  if (workspace === "automations" && route.run)
+    parameters.set("run", route.run);
   const query = parameters.toString();
   return query ? `${path}?${query}` : path;
 }

package/dist/src/web-ui/app/notifications-feature.js

@@ -4,6 +4,7 @@ import { createNotificationsController } from "./controllers/notifications-contr
 import { createNotificationPresence } from "./controllers/notification-presence.js";
 import { createHomeNotificationsEntry } from "./components/notifications/home-entry.js";
 import { notificationSourceUrl } from "./components/notifications/presentation.js";
+import { sparkNotificationReference } from "./lib/spark-chat-address.js";
 
 function isNotificationSummaryWorkspace(workspace) {
   return ["notifications", "home"].includes(workspace);
@@ -12,6 +13,7 @@ function isNotificationSummaryWorkspace(workspace) {
 export function createNotificationsFeature({ dom, state, client, shell, getEnvironmentId, send }) {
   mountNotificationsDom(dom);
   let view;
+  let companionChat;
   let environmentRevision = 0;
   const homeEntry = createHomeNotificationsEntry({
     homePanel: dom.homeWorkspacePanel,
@@ -39,6 +41,12 @@ export function createNotificationsFeature({ dom, state, client, shell, getEnvir
     if (item.environmentId !== getEnvironmentId()) return false;
     return shell.activeWorkspace() === "notifications";
   }
+  async function openCompanionSource(item, source) {
+    if (!companionChat) return false;
+    const address = new URL(source, window.location.href);
+    if (address.searchParams.get("spark") !== "1") return false;
+    return companionChat.openSession(item.sessionId, address.searchParams.get("message"), sparkNotificationReference(address));
+  }
   async function openNotificationSource(item) {
     if (!canOpenNotificationSource(item)) return;
     const source = notificationSourceUrl(item);
@@ -49,6 +57,10 @@ export function createNotificationsFeature({ dom, state, client, shell, getEnvir
     if (!canOpenNotificationSource(item)) return;
     if (environmentVersion !== environmentRevision) return;
     if (navigationVersion !== shell.navigationRevision()) return;
+    if (await openCompanionSource(item, source)) return;
+    if (!canOpenNotificationSource(item)) return;
+    if (environmentVersion !== environmentRevision) return;
+    if (navigationVersion !== shell.navigationRevision()) return;
     window.location.assign(source);
   }
   function refreshAvailability() {
@@ -68,6 +80,7 @@ export function createNotificationsFeature({ dom, state, client, shell, getEnvir
   controller.publish();
   return {
     ...controller,
+    setCompanionChat(companion) { companionChat = companion; },
     refreshAvailability,
     isWorkspaceAvailable(destination) {
       if (destination !== "notifications") return true;

package/dist/src/web-ui/app/passive-learning-feature.js

@@ -3,8 +3,6 @@ import { createPassiveLearningController } from "./controllers/passive-learning-
 import { createPassiveLearningHome } from "./components/passive-learning/home.js";
 import { createPassiveLearningMemory } from "./components/passive-learning/memory.js";
 import { selectLearningView } from "./components/passive-learning/workspace-view.js";
-import { createProposalNotifications } from "./components/passive-learning/proposal-notifications.js";
-import { visibleProposalSnapshot } from "./components/passive-learning/proposal-read-state.js";
 
 export function createPassiveLearningFeature({
   client,
@@ -13,30 +11,21 @@ export function createPassiveLearningFeature({
   openLearning,
   showActivityMemories,
   openComputerAccess,
-  openSession = () => {},
-  activateChat = () => true,
   onChange = () => {},
+  isRuntimeReady = () => true,
 }) {
   let home;
   let memory;
-  let sessionSnapshot;
   let collectionConsent;
   function renderViews(snapshot) {
     collectionConsent?.update(snapshot);
-    const visibleSnapshot = visibleProposalSnapshot(snapshot, sessionSnapshot);
-    home?.render(visibleSnapshot);
-    memory?.render(visibleSnapshot);
-  }
-  async function openConversation(sessionId, environmentId) {
-    if (environmentId !== getEnvironmentId()) return false;
-    if (activateChat() === false) return false;
-    await openSession(sessionId);
-    return true;
+    home?.render(snapshot);
+    memory?.render(snapshot);
   }
   const controller = createPassiveLearningController({
     client,
     getEnvironmentId,
-    openSession: openConversation,
+    isRuntimeReady,
     render: (snapshot) => {
       renderViews(snapshot);
       onChange();
@@ -62,10 +51,6 @@ export function createPassiveLearningFeature({
     openComputerAccess,
   });
   memory.mount(learningRoot);
-  const notifications = createProposalNotifications({
-    getEnvironmentId,
-    openSession: openConversation,
-  });
   return Object.freeze({
     ...actions,
     setWorkspace(workspace) {
@@ -74,25 +59,15 @@ export function createPassiveLearningFeature({
     },
     handleRealtime(message) {
       if (message?.type === "system-host.changed") collectionConsent.cancel();
-      notifications.handleRealtime(message);
       controller.handleRealtime(message);
     },
     environmentChanged() {
       collectionConsent.cancel();
-      sessionSnapshot = undefined;
-      notifications.environmentChanged();
       controller.environmentChanged();
     },
-    updateSessions(snapshot) {
-      if (snapshot.environmentId !== getEnvironmentId()) return;
-      sessionSnapshot = snapshot;
-      renderViews(controller.snapshot());
-    },
     mountHome: (root) => {
       home.mount(root);
-      home.render(
-        visibleProposalSnapshot(controller.snapshot(), sessionSnapshot),
-      );
+      home.render(controller.snapshot());
     },
   });
 }

package/dist/src/web-ui/app/projects-feature.js

@@ -9,6 +9,7 @@ export function createProjectsFeature({
   client,
   shell,
   selectedEnvironmentId,
+  isRuntimeReady = () => true,
   conversationSession,
   renderSessions,
   prepareConversation,
@@ -23,6 +24,7 @@ export function createProjectsFeature({
   const controller = createProjectsController({
     client,
     getEnvironmentId: selectedEnvironmentId,
+    isRuntimeReady,
     getConversationRevision: () =>
       `${state.currentSessionId}:${state.sessionViewVersion}`,
     prepareConversation,
@@ -31,11 +33,11 @@ export function createProjectsFeature({
     notify: shell.showToast,
     onSessionCreated,
     onChange: (snapshot) => {
-      const open = Boolean(snapshot.draft);
+      const open = Boolean(snapshot.draft) && isRuntimeReady();
       dom.chatPanel.classList.toggle("project-creation-open", open);
       dom.messagesList.inert = open;
       dom.composerForm.inert = open;
-      view?.render(snapshot.draft);
+      view?.render(open ? snapshot.draft : null);
       renderSessions();
       if (open && !wasOpen)
         dom.projectCreationRoot.querySelector("input")?.focus();
@@ -100,17 +102,26 @@ export function createProjectsFeature({
     expandedProjectSessionIds.delete(projectId);
   }
 
+  function canUseProjects() {
+    if (!isRuntimeReady()) return false;
+    return client.supportsProjects();
+  }
+
   function refreshAvailability() {
-    const available = client.supportsProjects();
+    const available = canUseProjects();
     dom.newProjectButton.disabled = !available;
     dom.newProjectButton.title = available
       ? "Create a project"
-      : "Projects are unavailable on this server";
+      : "Projects are currently unavailable";
   }
 
   return {
     load: controller.load,
     refreshAvailability,
+    runtimeAvailabilityChanged() {
+      refreshAvailability();
+      return controller.runtimeAvailabilityChanged();
+    },
     renderSessionGroups({ root, sessions, createSessionItem }) {
       syncProjectGroupEnvironment();
       const project = state.sessions.find(
@@ -141,7 +152,7 @@ export function createProjectsFeature({
     },
     bind() {
       dom.newProjectButton.addEventListener("click", () => {
-        if (!client.supportsProjects()) return;
+        if (!canUseProjects()) return;
         if (!shell.activateWorkspace("chat", { focus: false })) return;
         shell.setSessionsDrawerOpen(false);
         closeFilePreview();

package/dist/src/web-ui/app/runtime-onboarding-feature.js

@@ -52,6 +52,7 @@ export function createRuntimeOnboardingFeature({
       loadHostConnection: () => runtimeClient.getSystemHostConnection(),
       connectLocalHost: () => runtimeClient.connectLocalSystemHost(),
       createHostPairing: () => runtimeClient.createSystemHostPairing(),
+      requestHostPermissions: (input) => runtimeClient.requestSystemHostPermissions(input),
       downloadHostSetup: (platform) =>
         runtimeClient.downloadSystemHostSetup(platform),
       revokeHostConnection: () => runtimeClient.revokeSystemHostConnection(),

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

@@ -11,8 +11,6 @@ export declare function createClientPreferences(storage: Pick<
   Storage, "getItem" | "setItem" | "removeItem"
 >): {
   loadSessionSidebar(environmentId: string): SessionSidebarPreferences;
-  hasKeptSparkConversation(environmentId: string, sessionId: string): boolean;
-  keepSparkConversation(environmentId: string, sessionId: string): void;
   saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void;
   loadPinnedSessions(): string[];
   savePinnedSessions(sessionIds: readonly string[]): void;

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

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

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/learning.js

@@ -40,15 +40,6 @@ export function createPassiveLearningRequests({
         signal ? { signal } : {},
       );
     },
-    dismissPassiveLearningProposal(id, environmentId = getEnvironmentId()) {
-      return requestApi(
-        environmentPath(`/proposals/${encodeURIComponent(id)}`, environmentId),
-        {
-          method: "DELETE",
-          body: "{}",
-        },
-      );
-    },
     listPassiveLearningBatches(
       environmentId = getEnvironmentId(),
       { signal } = {},

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,7 +13,9 @@ export function createSystemHostRequests({ requestApi, getConfig }) {
 
   return {
     supportsSystemHostConnection,
-    getSystemHostConnection: () => requestSystemHost(),
+    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 = {}) =>

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

@@ -1,7 +1,9 @@
 import type { NotificationRequests } from "./runtime-web-client/notifications.js";
+import type { SparkChatRequests } from "./runtime-web-client/spark-chat.js";
 import type { ProjectRequests } from "./runtime-web-client/projects.js";
 import type { ToolApprovalRequests } from "./runtime-web-client/tool-approvals.js";
 import type { ConversationFileClient } from "./runtime-web-client/conversation-files.js";
+import type { AutomationRequests } from "./runtime-web-client/automations.js";
 import type { ModelRemovalInput } from "../../local-runtime/model-removal.js";
 import type { ModelSetupInput } from "../../local-runtime/model-setup-input.js";
 import type { SetupEmbeddingInput } from "../../local-runtime/setup-embedding-input.js";
@@ -83,6 +85,11 @@ export declare function createRuntimeWebClient(options: {
   fetchImpl?: typeof fetch;
   origin?: string;
 }): {
+  supportsSparkChat: SparkChatRequests["supportsSparkChat"];
+  loadSparkChat: SparkChatRequests["loadSparkChat"];
+  configureSparkChat: SparkChatRequests["configureSparkChat"];
+  createSparkHandoffSession: SparkChatRequests["createSparkHandoffSession"];
+  markSparkMessagesRead: SparkChatRequests["markSparkMessagesRead"];
   supportsNotifications: NotificationRequests["supportsNotifications"];
   listNotifications: NotificationRequests["listNotifications"];
   markNotificationsRead: NotificationRequests["markNotificationsRead"];
@@ -92,6 +99,7 @@ export declare function createRuntimeWebClient(options: {
   decideToolApproval: ToolApprovalRequests["decideToolApproval"];
   supportsSystemHostConnection(): boolean;
   getSystemHostConnection(): Promise<Record<string, unknown>>;
+  requestSystemHostPermissions(input: Record<string, unknown>): Promise<Record<string, unknown>>;
   connectLocalSystemHost(): Promise<Record<string, unknown>>;
   downloadSystemHostSetup(
     platform: "windows" | "macos" | "linux",
@@ -128,6 +136,22 @@ export declare function createRuntimeWebClient(options: {
     environmentId?: string,
   ): Promise<Record<string, unknown>>;
   supportsSchedules(): boolean;
+  supportsAutomations: AutomationRequests["supportsAutomations"];
+  listAutomations: AutomationRequests["listAutomations"];
+  createAutomation: AutomationRequests["createAutomation"];
+  getAutomationDraft: AutomationRequests["getAutomationDraft"];
+  mutateAutomationDraft: AutomationRequests["mutateAutomationDraft"];
+  deleteAutomationDraft: AutomationRequests["deleteAutomationDraft"];
+  validateAutomation: AutomationRequests["validateAutomation"];
+  publishAutomation: AutomationRequests["publishAutomation"];
+  setAutomationActive: AutomationRequests["setAutomationActive"];
+  setAutomationPermission: AutomationRequests["setAutomationPermission"];
+  getAutomationCatalog: AutomationRequests["getAutomationCatalog"];
+  startAutomationRun: AutomationRequests["startAutomationRun"];
+  listAutomationRuns: AutomationRequests["listAutomationRuns"];
+  getAutomationRun: AutomationRequests["getAutomationRun"];
+  stopAutomationRun: AutomationRequests["stopAutomationRun"];
+  rerunAutomationRun: AutomationRequests["rerunAutomationRun"];
   listSchedules(environmentId?: string): Promise<{ jobs: SchedulerJob[] }>;
   getSchedule(
     jobId: string,
@@ -316,10 +340,6 @@ export declare function createRuntimeWebClient(options: {
     environmentId?: string,
     options?: { signal?: AbortSignal },
   ): Promise<{ ok: true; items: Omit<LearningCandidateRecord, "embedding">[] }>;
-  dismissPassiveLearningProposal(
-    id: string,
-    environmentId?: string,
-  ): Promise<{ ok: true }>;
   listPassiveLearningBatches(
     environmentId?: string,
     options?: { signal?: AbortSignal },

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

@@ -1,10 +1,12 @@
 import { createNotificationRequests } from "./runtime-web-client/notifications.js";
+import { createSparkChatRequests } from "./runtime-web-client/spark-chat.js";
 import { createProjectRequests } from "./runtime-web-client/projects.js";
 import { createSystemHostRequests } from "./runtime-web-client/system-host.js";
 import { toolPermissionRequestError } from "../lib/tool-permission-mode.js";
 import { createConversationFileRequests } from "./runtime-web-client/conversation-files.js";
 import { createConfigurationRequests } from "./runtime-web-client/configuration.js";
 import { createScheduleRequests } from "./runtime-web-client/schedules.js";
+import { createAutomationRequests } from "./runtime-web-client/automations.js";
 import { createLongTermMemoryRequests } from "./runtime-web-client/memory.js";
 import { createPassiveLearningRequests } from "./runtime-web-client/learning.js";
 import { createToolApprovalRequests } from "./runtime-web-client/tool-approvals.js";
@@ -355,7 +357,7 @@ export function createRuntimeWebClient({
       getConfig,
     }),
     ...createConfigurationRequests({ requestApi, environmentQuery }),
-    ...createSystemHostRequests({ requestApi, getConfig }),
+    ...createSystemHostRequests({ requestApi, getConfig, getEnvironmentId }),
     ...longTermMemoryRequests,
     ...createPassiveLearningRequests({
       requestApi,
@@ -363,8 +365,10 @@ export function createRuntimeWebClient({
       environmentQuery,
     }),
     ...createScheduleRequests({ requestApi, getEnvironmentId, getConfig }),
+    ...createAutomationRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createProjectRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createToolApprovalRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createNotificationRequests({ requestApi, getEnvironmentId, getConfig }),
+    ...createSparkChatRequests({ requestApi, getEnvironmentId, getConfig }),
   };
 }