@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/lib/tool-automation-activity-fields.js

@@ -0,0 +1,59 @@
+const ACTION_TITLES = Object.freeze({
+  browse_catalog: "Browse tools",
+  catalog: "Browse tools",
+  prepare_draft: "Prepare draft",
+  list_drafts: "List drafts",
+  read_draft: "Read draft",
+  create_draft: "Create draft",
+  create_automation_draft: "Create draft",
+  apply_automation_draft_changes: "Update draft",
+  validate_draft: "Validate draft",
+  save_agent: "Save agent",
+  add_saved_agent: "Add saved agent",
+});
+
+function boundedAutomationText(value, limit = 500) {
+  if (typeof value !== "string") return "";
+  const text = value.trim();
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit - 1)}…`;
+}
+
+function textField(fields, label, value, limit) {
+  const text = boundedAutomationText(value, limit);
+  if (text) fields.push({ label, value: text });
+}
+
+function countField(fields, label, value, minimum = 0) {
+  if (!Number.isSafeInteger(value) || value < minimum) return;
+  fields.push({ label, value: String(value) });
+}
+
+function hasAutomationActivityTool(tool) {
+  return tool === "automations" || tool === "automation_builder";
+}
+
+/** Project only explicit Studio display metadata; never inspect a plan or draft. */
+export function automationActivityFields(meta, tool) {
+  if (!hasAutomationActivityTool(tool)) return null;
+  const action = boundedAutomationText(meta.automationAction, 128);
+  const activityTitle = Object.hasOwn(ACTION_TITLES, action)
+    ? ACTION_TITLES[action]
+    : "";
+  const automationId = boundedAutomationText(meta.automationId, 128);
+  const automationTitle = boundedAutomationText(meta.automationTitle, 160);
+  const sent = [];
+  textField(sent, "Action", activityTitle || action);
+  textField(sent, "Automation ID", automationId);
+  countField(sent, "Expected revision", meta.expectedRevision, 1);
+  textField(sent, "Step ID", meta.nodeId, 128);
+  textField(sent, "Agent ID", meta.agentId, 128);
+  textField(sent, "View", meta.view, 128);
+  textField(sent, "Tool", meta.toolName, 128);
+  textField(sent, "Operation", meta.operationId, 128);
+  return {
+    activityTitle,
+    target: automationTitle || automationId,
+    sent,
+  };
+}

package/dist/src/web-ui/app/lib/tool-process-activity-fields.js

@@ -1,6 +1,6 @@
 import { titleCaseEventValue } from "./event-presentation.js";
 
-const INPUT_TEXT_LIMIT = 4_096;
+const INPUT_TEXT_LIMIT = 8_192;
 
 function textField(fields, label, value, limit = 500) {
   if (typeof value !== "string" || value.length === 0) return;

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

@@ -16,11 +16,11 @@ export function dashboardRefreshResources(rawMessage, environmentId) {
   if (message.type === "workspace_changed") {
     const resources = Array.isArray(message.resources) ? message.resources : [];
     return resources.filter(
-      (resource) => resource === "sessions" || resource === "approvals",
+      (resource) => ["sessions", "approvals", "automations"].includes(resource),
     );
   }
   if (message.type === "event" && message.name === "scheduler.changed")
-    return ["activity", "sessions"];
+    return ["activity", "sessions", "automations"];
   if (message.type === "completed" || message.type === "failed")
     return ["sessions", "approvals"];
   if (message.type === "chat_message" || message.type === "chat_read_state")

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

@@ -2,9 +2,15 @@ export interface WorkspaceRoute {
   workspace: string;
   environment: string;
   session: string;
+  automationRun: string;
   category: string;
   tab: string;
   job: string;
+  automation: string;
+  run: string;
+  pluginSource?: string;
+  pluginRef?: string;
+  pluginPath?: string;
 }
 
 export function readWorkspaceRoute(

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,18 @@ 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"),
+    ...(workspace === "plugins" && parameters.has("pluginSource") ? { pluginSource: routeParameter(parameters, "pluginSource"), pluginRef: routeParameter(parameters, "pluginRef"), pluginPath: routeParameter(parameters, "pluginPath") } : {}),
   };
 }
 
@@ -44,13 +50,22 @@ 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 === "plugins") {
+    if (route.tab === "discover") parameters.set("tab", "discover");
+  }
   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();
@@ -50,7 +39,6 @@ export function createPassiveLearningFeature({
   home = createPassiveLearningHome({
     actions,
     openLearning,
-    openComputerAccess,
     openSetup: () => {
       if (openLearning() === false) return;
       if (learningRoot) selectLearningView(learningRoot, "settings");
@@ -62,10 +50,6 @@ export function createPassiveLearningFeature({
     openComputerAccess,
   });
   memory.mount(learningRoot);
-  const notifications = createProposalNotifications({
-    getEnvironmentId,
-    openSession: openConversation,
-  });
   return Object.freeze({
     ...actions,
     setWorkspace(workspace) {
@@ -74,25 +58,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

@@ -17,6 +17,7 @@ export function createRuntimeOnboardingFeature({
   const usesBridgeBackend = () => state.config?.backend === "bridge";
   let selectedGuide = null;
   let bindings = {};
+  shell?.runtimeAvailabilityChanged(state.runtimeAvailability);
 
   function createConfiguredGuide() {
     const common = {
@@ -52,6 +53,8 @@ export function createRuntimeOnboardingFeature({
       loadHostConnection: () => runtimeClient.getSystemHostConnection(),
       connectLocalHost: () => runtimeClient.connectLocalSystemHost(),
       createHostPairing: () => runtimeClient.createSystemHostPairing(),
+      requestHostStoreConnection: () => runtimeClient.requestSystemHostStoreConnection(),
+      requestHostPermissions: (input) => runtimeClient.requestSystemHostPermissions(input),
       downloadHostSetup: (platform) =>
         runtimeClient.downloadSystemHostSetup(platform),
       revokeHostConnection: () => runtimeClient.revokeSystemHostConnection(),
@@ -86,6 +89,7 @@ export function createRuntimeOnboardingFeature({
   };
   const controller = createRuntimeOnboardingController({
     state,
+    getEnvironmentId: selectedEnvironmentId,
     guide,
     reloadModels: () =>
       usesBridgeBackend() ? reloadCatalog() : reloadModels(),

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

@@ -32,7 +32,7 @@ export function createSchedulesFeature({
       if (!shell.activateWorkspace("chat")) return;
       if (!sessionId) return;
       try {
-        await openSession(sessionId);
+        await openSession(sessionId, { page: { targetRequestId: requestId } });
         if (!requestId) return;
         requestAnimationFrame(() => {
           const messages = [

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

@@ -1,8 +1,10 @@
+import { createPluginConfigurationRequests } from "./plugin-configuration.js";
 /** Configuration transport; credentials are sent once and never retained here. */
 export function createConfigurationRequests({ requestApi, environmentQuery }) {
   const scoped = (path, environmentId) =>
     path + "?environment=" + environmentQuery(environmentId);
   return {
+    ...createPluginConfigurationRequests({ requestApi, environmentQuery }),
     getRuntimeSetup(environmentId) {
       return requestApi(scoped("/runtime/setup", environmentId));
     },
@@ -42,6 +44,24 @@ export function createConfigurationRequests({ requestApi, environmentQuery }) {
         body: JSON.stringify(input),
       });
     },
+    inspectRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins/inspect", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    installRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins/install", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    removeRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins/remove", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
     applyRuntimeConfiguration(environmentId) {
       return requestApi(scoped("/runtime/config/apply", environmentId), {
         method: "POST",

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/plugin-configuration.js

@@ -0,0 +1,19 @@
+/** Plugin configuration transport never retains entered credentials. */
+export function createPluginConfigurationRequests({
+  requestApi,
+  environmentQuery,
+}) {
+  const path = (pluginId, environmentId) =>
+    `/runtime/plugins/configuration/${encodeURIComponent(pluginId)}?environment=${environmentQuery(environmentId)}`;
+  return {
+    getPluginConfiguration(pluginId, environmentId) {
+      return requestApi(path(pluginId, environmentId));
+    },
+    savePluginConfiguration(pluginId, input, environmentId) {
+      return requestApi(path(pluginId, environmentId), {
+        method: "PUT",
+        body: JSON.stringify(input),
+      });
+    },
+  };
+}

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, paged = false) {
+    if (!supportsSparkChat()) throw new Error("SPARK chat is unavailable with this backend.");
+    return `/runtime/spark/chat?${new URLSearchParams({ environment: environmentId, ...(paged ? { page: "1" } : {}) })}`;
+  }
+  return {
+    supportsSparkChat,
+    loadSparkChat(environmentId = getEnvironmentId()) {
+      return requestApi(path(environmentId, true));
+    },
+    configureSparkChat(input, environmentId = getEnvironmentId()) {
+      return requestApi(path(environmentId, true), {
+        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 }),
+      });
+    },
+  };
+}