@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/lib/context-window-state.js

@@ -0,0 +1,341 @@
+import { contextTransportSequenceDomain } from "./realtime-message.js";
+import {
+  canReplaceContextWindowEvidence,
+  hasOrderedContextEvidence,
+} from "./context-window-snapshot-order.js";
+import {
+  selectContextInputMeasurement,
+  normalizeContextProviderCounts,
+} from "./context-window-measurement.js";
+import {
+  reduceContextCompaction,
+  interruptContextCompactions,
+  projectContextCompactions,
+} from "./context-compaction-state.js";
+import { contextReplayBinding } from "./context-window-replay.js";
+
+function identityText(value) {
+  return typeof value === "string" ? value : "";
+}
+
+function matchesContextView(value, scope) {
+  if (!value) return false;
+  for (const key of [
+    "requestId",
+    "environmentId",
+    "sessionId",
+    "viewVersion",
+  ]) {
+    if (value[key] !== scope[key]) return false;
+  }
+  return true;
+}
+
+export function contextEvidenceScope(state, environmentId, requestId) {
+  const scope = {
+    requestId,
+    environmentId,
+    sessionId: state.currentSessionId,
+    viewVersion: state.sessionViewVersion,
+    generation: "",
+    generationSource: "legacy",
+    requestKnown: Boolean(
+      state.requestLifecycles?.has(requestId) ||
+      state.requestMessages?.has(requestId) ||
+      state.activeRequestId === requestId,
+    ),
+  };
+  const lifecycle = state.requestLifecycles?.get(requestId);
+  if (lifecycle)
+    return {
+      ...scope,
+      generation: identityText(lifecycle.generation),
+      generationSource: "lifecycle",
+    };
+  const previous = state.contextWindowByRequest?.get(requestId);
+  if (!matchesContextView(previous, scope) || !previous.generation)
+    return scope;
+  return {
+    ...scope,
+    generation: previous.generation,
+    generationSource: previous.generationSource || "event",
+  };
+}
+
+function hasMatchingReplayScope(replay, scope, event) {
+  if (!matchesContextView(replay, scope)) return false;
+  if (replay.generation === scope.generation) return true;
+  return (
+    !replay.generation &&
+    Boolean(scope.generation) &&
+    identityText(event.generation) === scope.generation
+  );
+}
+
+function canBindInitialGeneration(event, scope) {
+  if (!identityText(scope.environmentId).trim()) return false;
+  if (!identityText(scope.sessionId).trim()) return false;
+  if (scope.generation || scope.generationSource !== "legacy") return false;
+  if (!identityText(event.generation)) return false;
+  const replay = contextReplayBinding(event);
+  if (hasMatchingReplayScope(replay, scope, event)) return true;
+  return (
+    event.sessionId === scope.sessionId &&
+    (event.environment || event.environmentId) === scope.environmentId &&
+    hasOrderedContextEvidence(event)
+  );
+}
+
+function belongsToContextEvidenceScope(event, scope) {
+  if (!scope.requestKnown || !scope.requestId) return false;
+  if (event.requestId !== scope.requestId) return false;
+  const environmentId = identityText(event.environment || event.environmentId);
+  if (environmentId && environmentId !== scope.environmentId) return false;
+  const sessionId = identityText(event.sessionId);
+  if (sessionId && sessionId !== scope.sessionId) return false;
+  const replay = contextReplayBinding(event);
+  if (replay && !hasMatchingReplayScope(replay, scope, event)) return false;
+  const generation = identityText(event.generation);
+  if (generation)
+    return (
+      generation === scope.generation || canBindInitialGeneration(event, scope)
+    );
+  if (scope.generation) return hasMatchingReplayScope(replay, scope, event);
+  return true;
+}
+
+export function contextEvidenceOrder(event, scope) {
+  if (!belongsToContextEvidenceScope(event, scope)) return {};
+  const replay = contextReplayBinding(event);
+  const identity = [
+    scope.environmentId,
+    scope.sessionId,
+    scope.requestId,
+    scope.generation,
+  ];
+  return {
+    contextScope: JSON.stringify(identity),
+    sequenceDomain: JSON.stringify([
+      ...identity,
+      contextTransportSequenceDomain(event),
+    ]),
+    replayDomain: replay?.replayDomain,
+    replayOrder: replay?.replayOrder,
+  };
+}
+
+function bindContextEvidence(event, scope) {
+  return {
+    ...event,
+    requestId: scope.requestId,
+    invocationId: identityText(event.invocationId),
+    modelStep: identityText(event.modelStep),
+    profileId: identityText(event.profileId),
+    admissionOutcome: identityText(event.admissionOutcome),
+    generation: scope.generation,
+    sessionId: scope.sessionId,
+    environmentId: scope.environmentId,
+    ...contextEvidenceOrder(event, scope),
+  };
+}
+
+function isRequestTerminalEvidence(event, scope) {
+  if (event.type === "completed" || event.type === "failed") return true;
+  if (!scope.acceptedLifecycle || event.name !== "request.lifecycle.changed")
+    return false;
+  return ["completed", "failed"].includes(event.lifecycle?.status);
+}
+
+function createContextWindowState(scope) {
+  return {
+    ...scope,
+    latestSnapshotObservation: null,
+    lastValidSnapshot: null,
+    usageByInvocation: new Map(),
+    cycles: new Map(),
+    requestTerminal: null,
+    snapshot: null,
+    providerUsage: null,
+    pendingCompaction: null,
+    lastCompaction: null,
+    lastCompactionEvent: null,
+    openCompactionCount: 0,
+  };
+}
+
+function hasMatchingInvocationBinding(snapshot, usage) {
+  if (!snapshot?.invocationId || snapshot.invocationId !== usage?.invocationId)
+    return false;
+  for (const key of [
+    "requestId",
+    "generation",
+    "modelStep",
+    "profileId",
+    "provider",
+    "model",
+    "contextWindowTokens",
+    "activationId",
+    "modelInvocationScope",
+  ]) {
+    if (snapshot[key] === undefined || snapshot[key] === "") continue;
+    if (usage[key] === undefined || usage[key] === "") continue;
+    if (snapshot[key] !== usage[key]) return false;
+  }
+  return true;
+}
+
+function projectContextWindowState(current) {
+  const observation = current.latestSnapshotObservation;
+  const snapshot =
+    observation?.availability === "available"
+      ? { ...observation, ...observation.measurement }
+      : null;
+  const usage = current.usageByInvocation.get(observation?.invocationId);
+  const providerUsage = hasMatchingInvocationBinding(observation, usage)
+    ? usage
+    : null;
+  return {
+    ...current,
+    snapshot,
+    providerUsage,
+    ...projectContextCompactions(current.cycles),
+  };
+}
+
+function reduceContextSnapshot(current, event) {
+  if (
+    !canReplaceContextWindowEvidence(current.latestSnapshotObservation, event)
+  )
+    return current;
+  const measurement = selectContextInputMeasurement(event);
+  if (!measurement && !hasOrderedContextEvidence(event)) return current;
+  const observation = {
+    ...event,
+    availability: measurement ? "available" : "unavailable",
+    measurement,
+  };
+  return {
+    ...current,
+    latestSnapshotObservation: observation,
+    lastValidSnapshot: measurement ? observation : current.lastValidSnapshot,
+  };
+}
+
+function reduceContextProviderUsage(current, event) {
+  if (typeof event.invocationId !== "string" || !event.invocationId.trim())
+    return current;
+  const counts = normalizeContextProviderCounts(event);
+  if (!counts) return current;
+  const previous = current.usageByInvocation.get(event.invocationId);
+  if (!canReplaceContextWindowEvidence(previous, event)) return current;
+  const usage = {
+    ...event,
+    inputTokens: undefined,
+    outputTokens: undefined,
+    totalTokens: undefined,
+    ...counts,
+    source: "provider_reported",
+  };
+  return {
+    ...current,
+    usageByInvocation: new Map(current.usageByInvocation).set(
+      event.invocationId,
+      usage,
+    ),
+  };
+}
+
+function hasCurrentContextStateScope(previous, scope) {
+  if (!previous) return false;
+  for (const key of [
+    "requestId",
+    "generation",
+    "environmentId",
+    "sessionId",
+    "viewVersion",
+  ]) {
+    if (previous[key] !== scope[key]) return false;
+  }
+  return true;
+}
+
+export function reduceContextWindowEvidence(previous, message, scope) {
+  if (!belongsToContextEvidenceScope(message, scope)) return previous;
+  if (canBindInitialGeneration(message, scope))
+    scope = {
+      ...scope,
+      generation: message.generation,
+      generationSource: "event",
+    };
+  const event = bindContextEvidence(message, scope);
+  const hasContextEvent =
+    event.name?.startsWith("context.window.") ||
+    event.name?.startsWith("context.compaction.");
+  if (!hasContextEvent && !isRequestTerminalEvidence(event, scope))
+    return previous;
+  const current = hasCurrentContextStateScope(previous, scope)
+    ? previous
+    : createContextWindowState(scope);
+  let next = current;
+  if (event.name === "context.window.snapshot")
+    next = reduceContextSnapshot(current, event);
+  if (event.name === "context.window.provider_usage")
+    next = reduceContextProviderUsage(current, event);
+  if (event.name?.startsWith("context.compaction.")) {
+    const cycles = reduceContextCompaction(
+      current.cycles,
+      event,
+      current.requestTerminal,
+    );
+    if (cycles !== current.cycles) next = { ...current, cycles };
+  }
+  if (isRequestTerminalEvidence(event, scope)) {
+    if (!canReplaceContextWindowEvidence(current.requestTerminal, event))
+      return previous;
+    next = {
+      ...current,
+      requestTerminal: event,
+      cycles: interruptContextCompactions(current.cycles, event),
+    };
+  }
+  if (next === current) return previous;
+  return projectContextWindowState(next);
+}
+
+export function synchronizeContextRequestLifecycle(
+  state,
+  message,
+  environmentId,
+) {
+  const lifecycle = message.lifecycle;
+  const requestId = lifecycle.requestId;
+  if (state.requestLifecycles?.get(requestId) !== lifecycle) return;
+  const previous = state.contextWindowByRequest.get(requestId);
+  if (previous && previous.generation !== lifecycle.generation)
+    state.contextWindowByRequest.delete(requestId);
+  const current = state.contextWindowByRequest.get(requestId);
+  const scope = {
+    ...contextEvidenceScope(state, environmentId, requestId),
+    acceptedLifecycle: true,
+  };
+  const next = reduceContextWindowEvidence(
+    current,
+    { ...message, requestId, generation: lifecycle.generation },
+    scope,
+  );
+  if (next && next !== current)
+    state.contextWindowByRequest.set(requestId, next);
+}
+
+export function projectContextWindowDisplay(contextWindow, requestId) {
+  if (!contextWindow || contextWindow.requestId !== requestId) return null;
+  const snapshot = contextWindow.snapshot;
+  if (!snapshot || snapshot.availability !== "available") return null;
+  const { lastCompaction, providerUsage } = contextWindow;
+  return {
+    ...snapshot,
+    measurement: snapshot.measurementKind,
+    providerUsage,
+    compaction: lastCompaction,
+  };
+}

package/dist/src/web-ui/app/lib/conversation-status-model.js

@@ -41,13 +41,16 @@ function hasPendingRequestCompaction(contextWindow, requestId) {
 
 function hasAcceptedRequestSnapshot(contextWindow, requestId) {
   if (!hasMatchingContextRequest(contextWindow, requestId)) return false;
-  const snapshot = contextWindow.snapshot;
+  const snapshot =
+    contextWindow.latestSnapshotObservation || contextWindow.snapshot;
   if (!snapshot) return false;
   if (textOf(snapshot.requestId) !== requestId) return false;
   return snapshot.admissionOutcome === "accepted";
 }
 
 function isSettledToolAfterSnapshot(event, snapshot) {
+  if (snapshot.contextScope && event.contextScope !== snapshot.contextScope)
+    return false;
   const name = textOf(
     event.toolActivity?.name ||
       event.eventName ||
@@ -60,7 +63,9 @@ function isSettledToolAfterSnapshot(event, snapshot) {
 }
 
 function hasUsageForCurrentInvocation(contextWindow) {
-  const invocationId = textOf(contextWindow.snapshot?.invocationId);
+  const snapshot =
+    contextWindow.latestSnapshotObservation || contextWindow.snapshot;
+  const invocationId = textOf(snapshot?.invocationId);
   if (!invocationId) return false;
   return textOf(contextWindow.providerUsage?.invocationId) === invocationId;
 }
@@ -105,12 +110,19 @@ export function buildConversationStatus({
   if (!hasAcceptedRequestSnapshot(contextWindow, activeRequestId)) {
     return activeStatus("Working");
   }
-  const snapshot = contextWindow.snapshot;
+  const snapshot =
+    contextWindow.latestSnapshotObservation || contextWindow.snapshot;
   const settledAfterSnapshot = scopedEvents.some((event) =>
     isSettledToolAfterSnapshot(event, snapshot),
   );
   if (settledAfterSnapshot) return activeStatus("Working");
   if (hasUsageForCurrentInvocation(contextWindow))
     return activeStatus("Working");
+  if (
+    snapshot.modelStep === "context.compact" &&
+    contextWindow.cycles instanceof Map
+  ) {
+    return activeStatus("Working");
+  }
   return activeStatus(modelStepLabel(snapshot.modelStep));
 }

package/dist/src/web-ui/app/lib/history-page-messages.js

@@ -0,0 +1,49 @@
+import { isApprovalPresentation, mergeConversationMessage, sameConversationMessage } from "./request-lifecycle-view.js";
+
+function isRequestResponse(message) {
+  if (message.role !== "assistant") return false;
+  if (!message.requestId) return false;
+  return !isApprovalPresentation(message);
+}
+
+function indexConversationMessages(messages) {
+  const byId = new Map(messages.map((message) => [message.id, message]));
+  const byRequest = new Map();
+  for (const message of messages) {
+    if (!isRequestResponse(message)) continue;
+    const candidates = byRequest.get(message.requestId) || [];
+    candidates.push(message);
+    byRequest.set(message.requestId, candidates);
+  }
+  return (incoming) => {
+    if (!incoming) return undefined;
+    const exact = byId.get(incoming.id);
+    if (exact) return exact;
+    return byRequest.get(incoming.requestId)?.find((message) => sameConversationMessage(message, incoming));
+  };
+}
+
+/** Keep the contiguous loaded history before rows received from the live stream. */
+export function mergeHistoryPage(state, incoming, direction, windowEnd) {
+  const current = state.messages;
+  const findCurrent = indexConversationMessages(current);
+  const replaced = new Set();
+  const page = incoming.map((message) => {
+    const existing = findCurrent(message);
+    if (!existing) return message;
+    replaced.add(existing);
+    return mergeConversationMessage(existing, message);
+  });
+  const retained = (messages) => messages.filter((message) => !replaced.has(message));
+  if (direction === "older") {
+    state.messages = [...page, ...retained(current)];
+  } else {
+    const end = current.indexOf(findCurrent(windowEnd));
+    const split = end < 0 ? current.length : end + 1;
+    state.messages = [...retained(current.slice(0, split)), ...page, ...retained(current.slice(split))];
+  }
+  for (const message of state.messages) {
+    if (!isRequestResponse(message)) continue;
+    state.requestMessages?.set(message.requestId, message.id);
+  }
+}

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

@@ -1,12 +1,21 @@
 import { getRecord } from "./event-presentation.js";
 import { textOf } from "./text-format.js";
 
+const contextSequenceSource = Symbol("context sequence source");
+
+export function contextTransportSequenceDomain(message) {
+  if (message[contextSequenceSource]) return message[contextSequenceSource];
+  if (typeof message.seqNo === "number") return "transport";
+  return "original";
+}
+
 export function normalizeRealtimeMessage(raw) {
   const message = raw && typeof raw === "object" ? raw : {};
   const payload = getRecord(message.payload);
   return {
     ...message,
     ...(payload || {}),
+    [contextSequenceSource]: contextTransportSequenceDomain(message),
     type: textOf(message.type),
     rawType: textOf(message.rawType || message.type),
     requestId: textOf(message.requestId),

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

@@ -71,6 +71,14 @@ export function sameConversationMessage(existing, incoming) {
   return !existing.persistedMessageId || !incoming.persistedMessageId;
 }
 
+export function mergeConversationMessage(existing, incoming) {
+  return {
+    ...existing, ...incoming,
+    text: incoming.text || existing.text,
+    thinkingText: incoming.thinkingText || existing.thinkingText,
+  };
+}
+
 export function removeStreamingPlaceholder(state, requestId) {
   state.messages = state.messages.filter((message) => {
     if (message.requestId !== requestId || message.role !== "assistant")

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

@@ -0,0 +1,19 @@
+/** The permanent companion is intentionally omitted from ordinary session lists. */
+export function scheduleConversationLabel(sessionId, sessions = []) {
+  if (sessionId === "spark-companion") return "SPARK Chat";
+  const session = sessions.find((item) => item.id === sessionId);
+  return session?.title || sessionId;
+}
+
+export function scheduleConversationOptions(sessions, selectedSessionId) {
+  const options = sessions.map((session) => ({
+    value: session.id,
+    label: scheduleConversationLabel(session.id, sessions),
+  }));
+  if (!selectedSessionId) return options;
+  if (options.some((option) => option.value === selectedSessionId)) return options;
+  return [...options, {
+    value: selectedSessionId,
+    label: scheduleConversationLabel(selectedSessionId, sessions),
+  }];
+}

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

@@ -1,4 +1,5 @@
 import { scheduleTimeLabel } from "./schedule-message.js";
+import { scheduleConversationLabel } from "./schedule-conversation-presentation.js";
 export { scheduleErrorMessage } from "./schedule-errors.js";
 
 export const SCHEDULE_WEEKDAYS = [
@@ -47,12 +48,11 @@ export function matchesScheduleFilter(job, query, state, sessions = []) {
     .trim()
     .toLocaleLowerCase();
   if (!needle) return true;
-  const session = sessions.find((item) => item.id === job.sessionId);
   return [
     job.title,
     job.prompt,
     job.sessionId,
-    session?.title,
+    scheduleConversationLabel(job.sessionId, sessions),
     job.modelProfileId,
     scheduleDescription(job),
   ].some((value) =>

package/dist/src/web-ui/app/lib/spark-chat-address.js

@@ -0,0 +1,22 @@
+export function canRestoreSparkAddress(address, environmentId) {
+  if (address.searchParams.get("spark") !== "1") return false;
+  const requestedEnvironment = address.searchParams.get("environment");
+  if (!requestedEnvironment) return false;
+  return requestedEnvironment === environmentId;
+}
+
+export function sparkNotificationReference(address) {
+  const timestamp = address.searchParams.get("messageCreatedAt");
+  if (timestamp === null || !Number.isFinite(Number(timestamp))) return null;
+  return { createdAt: Number(timestamp), requestId: address.searchParams.get("request") || null };
+}
+
+export function resolveSparkMessageTarget(messages, id, reference) {
+  if (id === undefined || id === null) return undefined;
+  const message = (messages || []).find((entry) => String(entry.id) === String(id));
+  if (!message) return undefined;
+  if (reference === undefined) return String(message.id);
+  if (!reference || message.createdAt !== reference.createdAt) return undefined;
+  if ((message.requestId || null) !== reference.requestId) return undefined;
+  return String(message.id);
+}

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

@@ -0,0 +1,16 @@
+const ROUTINE_STATUS = new Set([
+  "ABot response completed.", "ABot is working.",
+  "Sending an update to the active request.", "Update accepted. ABot is working.",
+  "Queueing the next message.",
+]);
+
+export function sparkMessageStatus(text) {
+  const value = String(text || "");
+  if (value === "ABot request failed.") return "SPARK couldn’t reply. See the message above for details.";
+  return ROUTINE_STATUS.has(value) ? "" : value;
+}
+
+export function sparkWorkingStatus(model) {
+  if (!model || !model.animate) return model;
+  return { ...model, label: "SPARK is working…" };
+}

package/dist/src/web-ui/app/lib/spark-chat-read-state.js

@@ -0,0 +1,13 @@
+/** A receipt cannot erase messages that arrived after its visibility snapshot. */
+export function reconcileSparkReadState(previous, incoming, receipt) {
+  if (!incoming) return previous;
+  if (incoming.readStateStatus === "unavailable")
+    return previous ? { ...previous, readStateStatus: "unavailable" } : incoming;
+  const sameGeneration = previous?.readGeneration === incoming.readGeneration;
+  if (receipt && previous && !sameGeneration) return previous;
+  if (sameGeneration && Number(incoming.readRevision) < Number(previous.readRevision)) return previous;
+  const arrivedDuringRead = receipt ? (previous?.unreadMessageIds || []).map(String)
+    .filter((id) => !receipt.observedUnreadIds.includes(id)) : [];
+  const unreadMessageIds = [...new Set([...(incoming.unreadMessageIds || []).map(String), ...arrivedDuringRead])];
+  return { ...incoming, unreadMessageIds, unreadCount: unreadMessageIds.length, hasUnread: unreadMessageIds.length > 0 };
+}

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

@@ -4,3 +4,10 @@ export function sparkProposalId(message) {
   const id = message.initiative.proposalId;
   return typeof id === "string" ? id.trim() : "";
 }
+
+export function sparkHandoffAvailable(message) {
+  if (!sparkProposalId(message)) return false;
+  const { handoffBrief, handoffTitle } = message.initiative;
+  if (typeof handoffBrief !== "string" || !handoffBrief.trim() || handoffBrief.length > 4000) return false;
+  return typeof handoffTitle === "string" && Boolean(handoffTitle.trim()) && handoffTitle.length <= 160;
+}

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

@@ -5,6 +5,7 @@ export interface ToolActivityEvent {
   fileReference?: ConversationFileReference;
   name: string;
   tool: string;
+  activityTitle?: string;
   executionId: string;
   executorRole: string;
   roleCallId: string;

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

@@ -1,6 +1,7 @@
 import { getRecord, titleCaseEventValue } from "./event-presentation.js";
 import { projectConversationFileReference } from "./conversation-file-reference.js";
 import { computerInputFields } from "./tool-computer-activity-fields.js";
+import { automationActivityFields } from "./tool-automation-activity-fields.js";
 import {
   processInputFields,
   processResultFields,
@@ -192,8 +193,10 @@ export function projectToolActivityEvent(message) {
   const params = getRecord(meta.params);
   const inputMeta = { ...meta, params };
   const fileReference = projectConversationFileReference(message);
+  const automation = automationActivityFields(meta, tool);
   return {
     ...(fileReference ? { fileReference } : {}),
+    ...(automation?.activityTitle ? { activityTitle: automation.activityTitle } : {}),
     name,
     tool,
     executionId: boundedText(message.executionId, 200).trim(),
@@ -203,7 +206,8 @@ export function projectToolActivityEvent(message) {
     beforeExternalExecution: message.stage === "before_external_execution",
     intent: boundedText(message.intent || meta.intent),
     target: boundedText(
-      meta.source ||
+      automation?.target ||
+        meta.source ||
         meta.displayTarget ||
         meta.path ||
         meta.searchRoot ||
@@ -211,7 +215,7 @@ export function projectToolActivityEvent(message) {
         meta.id ||
         meta.savedId,
     ),
-    sent: inputFields(inputMeta, completed, tool),
+    sent: [...inputFields(inputMeta, completed, tool), ...(automation?.sent || [])],
     received: terminal ? resultFields(meta, tool, message.ok) : [],
     preview: terminal ? boundedText(meta.outputPreview, 1_200) : "",
     previewTruncated: terminal && hasClippedPreview(meta),

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

@@ -94,6 +94,7 @@ function applyPhase(action, evidence) {
 }
 
 function applyEvidence(action, evidence) {
+  if (evidence.activityTitle) action.title = evidence.activityTitle;
   if (isSettledToolEvent(evidence)) delete action.fileReference;
   if (evidence.fileReference) action.fileReference = evidence.fileReference;
   if (evidence.executorRole) action.executorRole = evidence.executorRole;

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

@@ -0,0 +1,7 @@
+/** Socket acknowledgements belong to the view that submitted that exact decision. */
+export function ownsToolApprovalAcknowledgement(message, state, environmentId) {
+  const messageEnvironment = message.environmentId || message.environment;
+  if (messageEnvironment && messageEnvironment !== environmentId) return false;
+  if (message.sessionId && message.sessionId !== state.currentSessionId) return false;
+  return state.submittedToolApprovalIds.has(message.approvalId);
+}