@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/app/lib/live-region.js

@@ -0,0 +1,96 @@
+// Retain an unchanged region and preserve its view state when content changes.
+const renderedRegions = new WeakMap();
+const identityAttributes = [
+  "id",
+  "data-session-id",
+  "data-request-id",
+  "data-job-id",
+  "data-run-id",
+  "data-disclosure-id",
+  "data-dashboard-action",
+  "data-template-id",
+  "data-job-action",
+  "data-run-page",
+  "data-open-request",
+  "data-open-conversation",
+  "data-state-action",
+];
+
+function nodePath(root, node) {
+  if (!node || !root.contains(node)) return null;
+  const path = [];
+  while (node !== root) {
+    const parent = node.parentElement;
+    path.unshift({
+      tag: node.tagName,
+      index: [...parent.children].indexOf(node),
+      identity: identityAttributes
+        .filter((name) => node.hasAttribute(name))
+        .map((name) => [name, node.getAttribute(name)]),
+    });
+    node = parent;
+  }
+  return path;
+}
+
+function matchesNodeIdentity(node, segment) {
+  if (node.tagName !== segment.tag) return false;
+  return segment.identity.every(
+    ([name, value]) => node.getAttribute(name) === value,
+  );
+}
+
+function resolveNodePath(root, path) {
+  if (!path) return null;
+  let node = root;
+  for (const segment of path) {
+    const children = [...node.children];
+    const candidate = segment.identity.length
+      ? children.find((child) => matchesNodeIdentity(child, segment))
+      : children[segment.index];
+    if (!candidate || candidate.tagName !== segment.tag) return null;
+    node = candidate;
+  }
+  return node;
+}
+
+function captureViewState(root) {
+  return {
+    focus: nodePath(root, root.ownerDocument.activeElement),
+    open: [...root.querySelectorAll("details[open]")].map((node) =>
+      nodePath(root, node),
+    ),
+    scroll: [root, ...root.querySelectorAll("*")]
+      .filter((node) => node.scrollTop || node.scrollLeft)
+      .map((node) => ({
+        path: nodePath(root, node),
+        top: node.scrollTop,
+        left: node.scrollLeft,
+      })),
+  };
+}
+
+function restoreViewState(root, state) {
+  for (const path of state.open) {
+    const node = resolveNodePath(root, path);
+    if (node) node.open = true;
+  }
+  resolveNodePath(root, state.focus)?.focus({ preventScroll: true });
+  for (const position of state.scroll) {
+    const node = resolveNodePath(root, position.path);
+    if (!node) continue;
+    node.scrollTop = position.top;
+    node.scrollLeft = position.left;
+  }
+}
+
+export function updateLiveRegion(root, markup) {
+  const previous = renderedRegions.get(root);
+  const ownsCurrentNodes = previous?.firstChild === root.firstChild;
+  if (ownsCurrentNodes && previous?.markup === markup) return false;
+  const state = previous && ownsCurrentNodes ? captureViewState(root) : null;
+  root.innerHTML = markup;
+  renderedRegions.set(root, { markup, firstChild: root.firstChild });
+  if (state) restoreViewState(root, state);
+  return true;
+}

package/dist/src/web-ui/app/lib/request-lifecycle-view.d.ts

@@ -0,0 +1,23 @@
+export declare function isApprovalPresentation(
+  message: Record<string, any>,
+): boolean;
+export declare function projectApprovalContinuations<T extends Record<string, any>>(
+  messages: T[],
+): T[];
+export declare function requestLifecycles(
+  state: Record<string, any>,
+): Map<string, any>;
+export declare function rememberRequestLifecycle(
+  state: Record<string, any>,
+  lifecycle: any,
+): boolean;
+export declare function hasWaitingApproval(state: Record<string, any>): boolean;
+export declare function waitingRequest(state: Record<string, any>): any;
+export declare function sameConversationMessage(
+  existing: Record<string, any>,
+  incoming: Record<string, any>,
+): boolean;
+export declare function removeStreamingPlaceholder(
+  state: Record<string, any>,
+  requestId: string,
+): void;

package/dist/src/web-ui/app/lib/request-lifecycle-view.js

@@ -0,0 +1,83 @@
+export function isApprovalPresentation(message) {
+  return message?.kind === "tool_approval_request";
+}
+
+/** Saved waits and their continuation share one visible response and timeline. */
+export function projectApprovalContinuations(messages) {
+  const approvalRequests = new Set(
+    messages
+      .filter(isApprovalPresentation)
+      .map((message) => message.requestId)
+      .filter(Boolean),
+  );
+  const responses = new Map();
+  for (const message of messages) {
+    if (!isApprovalContinuation(message, approvalRequests)) continue;
+    const first = responses.get(message.requestId)?.first ?? message;
+    responses.set(message.requestId, { first, latest: message });
+  }
+  return messages.flatMap((message) => {
+    if (!isApprovalContinuation(message, approvalRequests)) return [message];
+    const { first, latest } = responses.get(message.requestId);
+    if (message !== first) return [];
+    return [{ ...latest, createdAt: first.createdAt }];
+  });
+}
+
+function isApprovalContinuation(message, approvalRequests) {
+  if (message.role !== "assistant") return false;
+  return approvalRequests.has(message.requestId);
+}
+
+export function requestLifecycles(state) {
+  return (state.requestLifecycles ??= new Map());
+}
+
+export function rememberRequestLifecycle(state, lifecycle) {
+  if (lifecycle?.schemaVersion !== 1 || !lifecycle.requestId) return false;
+  const states = requestLifecycles(state);
+  const previous = states.get(lifecycle.requestId);
+  if (
+    previous?.generation === lifecycle.generation &&
+    previous.revision > lifecycle.revision
+  )
+    return false;
+  states.set(lifecycle.requestId, lifecycle);
+  return true;
+}
+
+export function hasWaitingApproval(state) {
+  return [...requestLifecycles(state).values()].some(
+    (value) => value.status === "awaiting_approval",
+  );
+}
+
+export function waitingRequest(state) {
+  return [...requestLifecycles(state).values()].find(
+    (value) => value.status === "awaiting_approval",
+  );
+}
+
+export function sameConversationMessage(existing, incoming) {
+  if (incoming.id && existing.id === incoming.id) return true;
+  if (isApprovalPresentation(existing) || isApprovalPresentation(incoming))
+    return false;
+  if (!incoming.requestId || existing.requestId !== incoming.requestId)
+    return false;
+  if (existing.role !== "assistant" || incoming.role !== "assistant")
+    return false;
+  // Merge the optimistic streaming row into its saved answer. Persisted entries
+  // retain their own identities even when they belong to one logical request.
+  return !existing.persistedMessageId || !incoming.persistedMessageId;
+}
+
+export function removeStreamingPlaceholder(state, requestId) {
+  state.messages = state.messages.filter((message) => {
+    if (message.requestId !== requestId || message.role !== "assistant")
+      return true;
+    if (message.persistedMessageId || isApprovalPresentation(message))
+      return true;
+    return !message.streaming;
+  });
+  state.requestMessages.delete(requestId);
+}

package/dist/src/web-ui/app/lib/request-stop-state.js

@@ -0,0 +1,53 @@
+export function isStopResult(message) {
+  return (message?.error ?? message?.payload?.error) === "request_cancelled";
+}
+
+export function isStoppedRequest(request) {
+  return (
+    request?.status === "failed" &&
+    (isStopResult(request.finalState) ||
+      request.events?.some(isStopResult) === true)
+  );
+}
+
+export function stoppedResponseText(partial = "", terminal) {
+  const persisted = terminal?.details?.stoppedResponse;
+  if (typeof persisted === "string" && persisted.trim()) return persisted;
+  return partial.trim()
+    ? `${partial}\n\n_Response stopped._`
+    : "Response stopped.";
+}
+
+export function restoreStoppedResponses(messages, requests) {
+  for (const request of requests) {
+    if (!isStoppedRequest(request)) continue;
+    if (
+      messages.some(
+        (message) =>
+          message.role === "assistant" &&
+          message.kind !== "tool_approval_request" &&
+          message.requestId === request.requestId,
+      )
+    )
+      continue;
+    const tokens = (request.events ?? []).filter((entry) => {
+      const event = entry.payload ?? entry;
+      return (event.name ?? event.type) === "token";
+    });
+    // Persisted runtime token events contain the accumulated answer, not deltas.
+    const lastToken = tokens.at(-1);
+    const partial = String((lastToken?.payload ?? lastToken)?.text ?? "");
+    const after = messages.findLastIndex(
+      (message) => message.requestId === request.requestId,
+    );
+    const response = {
+      id: `stopped-${request.requestId}`,
+      role: "assistant",
+      requestId: request.requestId,
+      text: stoppedResponseText(partial),
+      createdAt: request.updatedAt,
+      streaming: false,
+    };
+    messages.splice(after < 0 ? messages.length : after + 1, 0, response);
+  }
+}

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

@@ -62,6 +62,16 @@ export function matchesScheduleFilter(job, query, state, sessions = []) {
   );
 }
 
+export function scheduleListJobs(jobs, query, state, sessions = []) {
+  const matches = jobs.filter((job) =>
+    matchesScheduleFilter(job, query, state, sessions),
+  );
+  return [
+    ...matches.filter((job) => job.state === "active"),
+    ...matches.filter((job) => job.state !== "active"),
+  ];
+}
+
 export function canManageSchedule(job) {
   if (!job) return false;
   return job.state !== "cancelled";

package/dist/src/web-ui/app/lib/session-archive-visibility.js

@@ -0,0 +1,4 @@
+export function filterSessionsByArchiveState(sessions, archivedSessionIds = [], archivedOnly = false) {
+  const archived = new Set(archivedSessionIds);
+  return sessions.filter((session) => archived.has(session.id) === archivedOnly);
+}

package/dist/src/web-ui/app/lib/session-sidebar-order.js

@@ -0,0 +1,35 @@
+export function sessionSidebarGroup(session, pinnedSessionIds) {
+  if (pinnedSessionIds.includes(session.id)) return "pinned";
+  const projectId = session.projectId || session.project?.id;
+  if (projectId) return `project:${projectId}`;
+  return "ordinary";
+}
+
+export function canReorderSidebarSessions(source, target, pinnedSessionIds) {
+  if (!source || !target) return false;
+  if (source.id === target.id) return false;
+  return sessionSidebarGroup(source, pinnedSessionIds) ===
+    sessionSidebarGroup(target, pinnedSessionIds);
+}
+
+export function orderSidebarSessions(sessions, pinnedSessionIds, orderedSessionIds) {
+  const pinnedOrder = new Map(pinnedSessionIds.map((id, index) => [id, index]));
+  const manualOrder = new Map(orderedSessionIds.map((id, index) => [id, index]));
+  return [...sessions].sort((left, right) => {
+    const leftPinned = pinnedOrder.has(left.id);
+    const rightPinned = pinnedOrder.has(right.id);
+    if (leftPinned !== rightPinned) return leftPinned ? -1 : 1;
+    if (leftPinned) return pinnedOrder.get(left.id) - pinnedOrder.get(right.id);
+    return (manualOrder.get(left.id) ?? -1) - (manualOrder.get(right.id) ?? -1);
+  });
+}
+
+export function moveSidebarSession(sessionIds, sourceId, targetId, placement) {
+  if (sourceId === targetId) return sessionIds;
+  if (!sessionIds.includes(sourceId)) return sessionIds;
+  if (!sessionIds.includes(targetId)) return sessionIds;
+  const next = sessionIds.filter((id) => id !== sourceId);
+  const offset = placement === "after" ? 1 : 0;
+  next.splice(next.indexOf(targetId) + offset, 0, sourceId);
+  return next;
+}

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

@@ -0,0 +1,6 @@
+export function sparkProposalId(message) {
+  if (message?.role !== "assistant" || message?.source !== "co_worker") return "";
+  if (message.initiative?.kind !== "proactive_proposal_v1") return "";
+  const id = message.initiative.proposalId;
+  return typeof id === "string" ? id.trim() : "";
+}

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

@@ -1,5 +1,6 @@
 import { getRecord, titleCaseEventValue } from "./event-presentation.js";
 import { projectConversationFileReference } from "./conversation-file-reference.js";
+import { computerInputFields } from "./tool-computer-activity-fields.js";
 import {
   processInputFields,
   processResultFields,
@@ -52,7 +53,7 @@ function lineRange(start, end) {
 }
 
 function inputFields(meta, completed, tool) {
-  const fields = processInputFields(meta);
+  const fields = [...processInputFields(meta), ...computerInputFields(meta)];
   addText(fields, "Query", meta.query);
   addText(fields, "Path", meta.path);
   if (!meta.source || meta.displayTarget !== ".")

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

@@ -1,5 +1,6 @@
 import { titleCaseEventValue } from "./event-presentation.js";
 import { projectToolActivityEvent } from "./tool-activity-event.js";
+import { correlateToolApprovalActivity } from "./tool-approval-activity.js";
 
 const TITLES = Object.freeze({
   dev_view: "Read",
@@ -25,9 +26,9 @@ const PHASES = Object.freeze({
   "tool.approval.required": [3, "awaiting_approval", "Awaiting approval"],
   "tool.approval.granted": [4, "preparing", "Approved"],
   "tool.started": [5, "running", "Running"],
-  "tool.payload.failed": [6, "failed", "Preparation failed"],
+  "tool.payload.failed": [6, "failed", "Not prepared"],
   "tool.approval.rejected": [6, "failed", "Not approved"],
-  "tool.failed": [6, "failed", "Failed"],
+  "tool.failed": [6, "failed", "Not completed"],
   "tool.completed": [6, "completed", "Completed"],
 });
 
@@ -35,7 +36,7 @@ const SETTLED_LABELS = Object.freeze({
   completed: "Completed",
   empty: "No results",
   unchanged: "No change",
-  failed: "Failed",
+  failed: "Not completed",
   incomplete: "Outcome not recorded",
 });
 
@@ -154,7 +155,7 @@ function canAdvanceToolPhase(phase, evidence, nextRank) {
   return nextRank >= phase.rank;
 }
 
-function finishAction(group, streaming) {
+function finishAction(group, streaming, requestEnded) {
   const action = initialAction(
     group.id,
     group.entries[0].evidence,
@@ -172,13 +173,29 @@ function finishAction(group, streaming) {
     }
     applyPhase(action, evidence);
   }
-  if (!streaming && phase.rank < 6) {
+  if (hasUnrecordedCompletion(action, streaming, phase.rank, requestEnded)) {
     action.status = "incomplete";
     action.statusLabel = "Completion not recorded";
   }
   return action;
 }
 
+function hasUnrecordedCompletion(action, streaming, rank, requestEnded) {
+  if (streaming || rank >= 6) return false;
+  if (action.status === "awaiting_approval" && !requestEnded) return false;
+  return true;
+}
+
+function isTerminalRequestEvent(event) {
+  const name = event.eventName || event.name || event.type;
+  return [
+    "completed",
+    "failed",
+    "request.completed",
+    "request.failed",
+  ].includes(name);
+}
+
 /** Lifecycle correlation is exact. Older, uncorrelated history supplies outcome rows only. */
 export function buildConversationToolActions({
   requestId,
@@ -187,7 +204,11 @@ export function buildConversationToolActions({
 }) {
   const groups = new Map();
   const seen = new Set();
-  for (const [index, event] of events.entries()) {
+  const correlated = correlateToolApprovalActivity(events, requestId);
+  const requestEnded = events.some(
+    (event) => event.requestId === requestId && isTerminalRequestEvent(event),
+  );
+  for (const [index, event] of correlated.entries()) {
     if (event.requestId !== requestId) continue;
     const evidence = event.toolActivity || projectToolActivityEvent(event);
     if (!evidence) continue;
@@ -209,7 +230,9 @@ export function buildConversationToolActions({
     group.entries.push({ evidence, sequence });
     groups.set(id, group);
   }
-  return [...groups.values()].map((group) => finishAction(group, streaming));
+  return [...groups.values()].map((group) =>
+    finishAction(group, streaming, requestEnded),
+  );
 }
 
 const CATEGORIES = Object.freeze({

package/dist/src/web-ui/app/lib/tool-approval-activity.d.ts

@@ -0,0 +1,4 @@
+export declare function correlateToolApprovalActivity(
+  events: Record<string, any>[],
+  requestId: string,
+): Record<string, any>[];

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

@@ -0,0 +1,33 @@
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+
+/** Older saved decisions carry approvalId but omit the execution identity. */
+export function correlateToolApprovalActivity(events, requestId) {
+  const approvals = new Map();
+  for (const event of events) {
+    if (event?.requestId !== requestId || !event.approvalId) continue;
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    if (evidence?.name !== "tool.approval.required") continue;
+    if (evidence.executionId) approvals.set(event.approvalId, evidence);
+  }
+  return events.map((event) => {
+    if (event?.requestId !== requestId) return event;
+    const required = approvals.get(event.approvalId);
+    if (!required) return event;
+    const evidence =
+      event.toolActivity ||
+      projectToolActivityEvent({
+        ...event,
+        tool: event.tool || required.tool,
+      });
+    if (!evidence?.name.startsWith("tool.approval.")) return event;
+    return {
+      ...event,
+      toolActivity: {
+        ...evidence,
+        executionId: evidence.executionId || required.executionId,
+        executorRole: evidence.executorRole || required.executorRole,
+        roleCallId: evidence.roleCallId || required.roleCallId,
+      },
+    };
+  });
+}

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

@@ -0,0 +1,74 @@
+const COMPUTER_ACTIONS = new Set([
+  "click",
+  "move",
+  "drag",
+  "scroll",
+  "type_text",
+  "press_keys",
+  "focus_window",
+]);
+
+function hasRecordedComputerAction(meta) {
+  return COMPUTER_ACTIONS.has(meta.computerAction);
+}
+
+function isTypedTextAction(meta) {
+  return meta.computerAction === "type_text";
+}
+
+function textField(fields, label, value, limit = 128) {
+  if (typeof value !== "string" || value.length === 0) return;
+  fields.push({ label, value: value.slice(0, limit) });
+}
+
+function numberField(fields, label, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return;
+  fields.push({ label, value: String(value) });
+}
+
+function hasCompleteTypedText(meta, text) {
+  if (meta.computerTextLength === 0) return text === "";
+  if (meta.computerTextTruncated !== false) return false;
+  if (text.length > 4_096) return false;
+  return text.length === meta.computerTextLength;
+}
+
+function hasCompleteKeyChord(meta) {
+  if (!Array.isArray(meta.computerKeys)) return false;
+  if (meta.computerKeys.length > 8) return false;
+  if (meta.computerKeysTruncated !== false) return false;
+  return meta.computerKeys.every(
+    (key) => typeof key === "string" && key.length <= 32,
+  );
+}
+
+/** Inert plugin-declared display evidence; never infer controls from intent. */
+export function computerInputFields(meta) {
+  if (!hasRecordedComputerAction(meta)) return [];
+  const fields = [{ label: "Action", value: meta.computerAction }];
+  textField(fields, "Observation reference", meta.computerObservation);
+  textField(fields, "Window reference", meta.computerWindow);
+  numberField(fields, "Image X", meta.computerX);
+  numberField(fields, "Image Y", meta.computerY);
+  numberField(fields, "From image X", meta.computerFromX);
+  numberField(fields, "From image Y", meta.computerFromY);
+  numberField(fields, "To image X", meta.computerToX);
+  numberField(fields, "To image Y", meta.computerToY);
+  textField(fields, "Button", meta.computerButton);
+  numberField(fields, "Click count", meta.computerClickCount);
+  numberField(fields, "Duration (ms)", meta.computerDurationMs);
+  numberField(fields, "Horizontal scroll", meta.computerDeltaX);
+  numberField(fields, "Vertical scroll", meta.computerDeltaY);
+  if (isTypedTextAction(meta)) {
+    const text = typeof meta.computerText === "string" ? meta.computerText : "";
+    const label = hasCompleteTypedText(meta, text)
+      ? "Typed text"
+      : "Typed text excerpt";
+    fields.push({ label, value: text.slice(0, 4_096) });
+    numberField(fields, "Text characters", meta.computerTextLength);
+  }
+  if (hasCompleteKeyChord(meta)) {
+    fields.push({ label: "Keys", value: JSON.stringify(meta.computerKeys) });
+  }
+  return fields;
+}

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

@@ -0,0 +1,34 @@
+import { normalizeRealtimeMessage } from "./realtime-message.js";
+
+export function isWorkspaceChange(message) {
+  if (message.type === "workspace_changed") return true;
+  if (message.type === "learning.changed") return true;
+  return (
+    message.type === "event" &&
+    ["scheduler.changed", "session.messages.updated"].includes(message.name)
+  );
+}
+
+export function dashboardRefreshResources(rawMessage, environmentId) {
+  const message = normalizeRealtimeMessage(rawMessage);
+  if ((message.environment || message.environmentId) !== environmentId)
+    return [];
+  if (message.type === "workspace_changed") {
+    const resources = Array.isArray(message.resources) ? message.resources : [];
+    return resources.filter(
+      (resource) => resource === "sessions" || resource === "approvals",
+    );
+  }
+  if (message.type === "event" && message.name === "scheduler.changed")
+    return ["activity", "sessions"];
+  if (message.type === "completed" || message.type === "failed")
+    return ["sessions", "approvals"];
+  if (message.type === "chat_message" || message.type === "chat_read_state")
+    return ["sessions"];
+  if (
+    message.type === "event" &&
+    ["session.title.updated", "session.messages.updated"].includes(message.name)
+  )
+    return ["sessions"];
+  return [];
+}

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

@@ -0,0 +1,21 @@
+export interface WorkspaceRoute {
+  workspace: string;
+  environment: string;
+  session: string;
+  category: string;
+  tab: string;
+  job: string;
+}
+
+export function readWorkspaceRoute(
+  location: Pick<Location, "pathname" | "search">,
+): WorkspaceRoute;
+
+export function workspaceRouteUrl(
+  route: Partial<WorkspaceRoute> & Record<string, unknown>,
+): string;
+
+export function configuredRouteEnvironment(
+  environmentId: string,
+  options: Array<{ value: string }>,
+): boolean;

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

@@ -0,0 +1,60 @@
+import { configurationCategoryForWorkspace, legacyConfigurationWorkspace } from "./configuration-pages.js";
+
+const WORKSPACE_PATHS = Object.freeze({
+  home: "/home",
+  notifications: "/notifications",
+  chat: "/chat",
+  schedules: "/schedules",
+  learning: "/learning",
+  memory: "/memory",
+  models: "/models",
+  plugins: "/plugins",
+  config: "/system",
+});
+
+function routeParameter(parameters, name) {
+  const value = parameters.get(name) || "";
+  return value.length <= 512 ? value : "";
+}
+
+export function readWorkspaceRoute(location) {
+  const path = location.pathname.replace(/\/$/, "") || "/";
+  const requestedWorkspace = Object.keys(WORKSPACE_PATHS).find(
+    (name) => WORKSPACE_PATHS[name] === path,
+  );
+  const parameters = new URLSearchParams(location.search);
+  const requestedCategory = routeParameter(parameters, "category");
+  const workspace = path === "/config"
+    ? legacyConfigurationWorkspace(requestedCategory)
+    : requestedWorkspace || "home";
+  return {
+    workspace,
+    environment: routeParameter(parameters, "environment"),
+    session: routeParameter(parameters, "session"),
+    category: configurationCategoryForWorkspace(workspace) || "",
+    tab: routeParameter(parameters, "tab"),
+    job: routeParameter(parameters, "job"),
+  };
+}
+
+export function workspaceRouteUrl(route) {
+  const workspace = route.workspace === "config" && route.category
+    ? legacyConfigurationWorkspace(route.category)
+    : route.workspace;
+  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)
+    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);
+  const query = parameters.toString();
+  return query ? `${path}?${query}` : path;
+}
+
+export function configuredRouteEnvironment(environmentId, options) {
+  return options.some((option) => option.value === environmentId);
+}