@abot-ai/runtime 1.3.1 → 1.5.0

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

@@ -1,4 +1,5 @@
 import { textOf } from "./text-format.js";
+import { isStopResult } from "./request-stop-state.js";
 
 function canMergeEventTimelineEntries(previous, event, name, summary) {
   if (!previous) return false;
@@ -152,27 +153,34 @@ export function formatEventLabel(message) {
     return "Response ready";
   }
   if (name === "request.failed" || message.type === "failed") {
-    return "Response failed";
+    return isStopResult(message) ? "Response stopped" : "Response failed";
   }
   if (name === "runtime.state") {
     return status || textOf(message.output) || "Runtime state";
   }
   if (name === "tool.intent") return "Next action";
+  if (isUncompletedToolEvent(message))
+    return uncompletedToolLabel(message, name);
   if (name.startsWith("tool.")) {
     const toolName = formatToolName(message.tool);
     if (status) return status;
     if (name === "tool.completed") {
       return toolName ? `${toolName} completed` : "Tool completed";
     }
-    if (name === "tool.failed") {
-      return toolName ? `${toolName} failed` : "Tool failed";
-    }
     return toolName ? `Using ${toolName}` : "Using a tool";
   }
   return titleCaseEventValue(name) || "Event";
 }
 
+function uncompletedToolLabel(message, name) {
+  if (name === "tool.approval.rejected") return "Tool not approved";
+  if (name === "tool.payload.failed") return "Tool not prepared";
+  const toolName = formatToolName(message.tool);
+  return toolName ? `${toolName} not completed` : "Tool not completed";
+}
+
 export function formatEventDetail(message) {
+  if (isStopResult(message)) return "Stopped by you.";
   const parts = [];
   const name = textOf(message.name || message.rawType || message.type);
   const plan = getPlanPayload(message);
@@ -203,6 +211,8 @@ export function formatEventDetail(message) {
 export function eventTone(message) {
   const name = textOf(message.name || message.type);
   const normalized = name.toLowerCase();
+  if (isStopResult(message)) return "neutral";
+  if (isUncompletedToolEvent(message)) return "neutral";
   if (
     message.ok === false ||
     textOf(message.status).toLowerCase() === "failed" ||
@@ -226,6 +236,17 @@ export function eventTone(message) {
   return "active";
 }
 
+export function isUncompletedToolEvent(message) {
+  const name = textOf(message.eventName || message.name || message.type);
+  if (!name.startsWith("tool.")) return false;
+  if (message.ok === false || message.toolActivity?.ok === false) return true;
+  return [
+    "tool.failed",
+    "tool.payload.failed",
+    "tool.approval.rejected",
+  ].includes(name);
+}
+
 export function isLowValueActivityEvent(message) {
   const name = textOf(message.name || message.rawType || message.type);
   const type = textOf(message.type);

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

@@ -0,0 +1,85 @@
+export function createEventRefresh({
+  canRefresh,
+  refresh,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  let timer;
+  let generation = { pending: null, queued: false };
+
+  function clearScheduled() {
+    if (timer !== undefined) clearTimer(timer);
+    timer = undefined;
+  }
+
+  function cancel() {
+    clearScheduled();
+    generation.queued = false;
+    generation = { pending: null, queued: false };
+  }
+
+  function hasQueuedRefresh(current) {
+    if (current !== generation) return false;
+    if (!current.queued) return false;
+    return canRefresh();
+  }
+
+  async function drain(current) {
+    do {
+      current.queued = false;
+      await refresh();
+    } while (hasQueuedRefresh(current));
+  }
+
+  function run() {
+    clearScheduled();
+    if (!canRefresh()) {
+      cancel();
+      return Promise.resolve();
+    }
+    const current = generation;
+    if (current.pending) {
+      current.queued = true;
+      return current.pending;
+    }
+    let resolve;
+    let reject;
+    const pending = new Promise((done, failed) => {
+      resolve = done;
+      reject = failed;
+    });
+    current.pending = pending;
+    function failed(error) {
+      current.pending = null;
+      reject(error);
+    }
+    function finished() {
+      if (hasQueuedRefresh(current)) {
+        void drain(current).then(finished, failed);
+        return;
+      }
+      current.pending = null;
+      resolve();
+    }
+    void drain(current).then(finished, failed);
+    return pending;
+  }
+
+  function schedule() {
+    if (!canRefresh()) {
+      cancel();
+      return;
+    }
+    if (generation.pending) {
+      generation.queued = true;
+      return;
+    }
+    clearScheduled();
+    timer = setTimer(() => {
+      timer = undefined;
+      void run();
+    }, 80);
+  }
+
+  return { run, schedule, cancel };
+}

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.d.ts

@@ -1,6 +1,8 @@
+import type { ConversationFileReference } from "./conversation-file-reference.js";
 import type { ToolActivityField } from "./tool-activity-model.js";
 
 export interface ToolActivityEvent {
+  fileReference?: ConversationFileReference;
   name: string;
   tool: string;
   executionId: string;

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

@@ -1,4 +1,10 @@
 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,
+} from "./tool-process-activity-fields.js";
 
 const TOOL_EVENTS = new Set([
   "tool.payload.started",
@@ -47,7 +53,7 @@ function lineRange(start, end) {
 }
 
 function inputFields(meta, completed, tool) {
-  const fields = [];
+  const fields = [...processInputFields(meta), ...computerInputFields(meta)];
   addText(fields, "Query", meta.query);
   addText(fields, "Path", meta.path);
   if (!meta.source || meta.displayTarget !== ".")
@@ -87,7 +93,7 @@ function resultCountLabel(tool) {
 }
 
 function resultFields(meta, tool, ok) {
-  const fields = [];
+  const fields = processResultFields(meta);
   if (hasCompletedFileWindow(meta, ok)) {
     addText(fields, "Read lines", lineRange(meta.startLine, meta.endLine));
   }
@@ -182,9 +188,12 @@ export function projectToolActivityEvent(message) {
   if (!tool) return null;
   const meta = effectiveToolMetadata(getRecord(message.meta) || {}, tool);
   const completed = name === "tool.completed";
+  const terminal = isTerminalToolExecutionEvent(name);
   const params = getRecord(meta.params);
   const inputMeta = { ...meta, params };
+  const fileReference = projectConversationFileReference(message);
   return {
+    ...(fileReference ? { fileReference } : {}),
     name,
     tool,
     executionId: boundedText(message.executionId, 200).trim(),
@@ -203,16 +212,20 @@ export function projectToolActivityEvent(message) {
         meta.savedId,
     ),
     sent: inputFields(inputMeta, completed, tool),
-    received: completed ? resultFields(meta, tool, message.ok) : [],
-    preview: completed ? boundedText(meta.outputPreview, 1_200) : "",
-    previewTruncated: completed && hasClippedPreview(meta),
-    partial: completed && hasPartialSource(meta),
+    received: terminal ? resultFields(meta, tool, message.ok) : [],
+    preview: terminal ? boundedText(meta.outputPreview, 1_200) : "",
+    previewTruncated: terminal && hasClippedPreview(meta),
+    partial: terminal && hasPartialSource(meta),
     outcome: completedOutcome(meta),
     ok: typeof message.ok === "boolean" ? message.ok : null,
     error: boundedText(message.error || message.reason || meta.errorCode),
   };
 }
 
+function isTerminalToolExecutionEvent(name) {
+  return name === "tool.completed" || name === "tool.failed";
+}
+
 function effectiveToolMetadata(meta, tool) {
   if (tool !== "document_reader") return meta;
   if (meta.sourceMode === "working_path") return { ...meta, source: undefined };

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

@@ -1,9 +1,11 @@
+import type { ConversationFileReference } from "./conversation-file-reference.js";
 export interface ToolActivityField {
   label: string;
   value: string;
 }
 
 export interface ConversationToolAction {
+  fileReference?: ConversationFileReference;
   id: string;
   tool: string;
   executorRole?: string;

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",
 });
 
@@ -93,6 +94,8 @@ function applyPhase(action, evidence) {
 }
 
 function applyEvidence(action, evidence) {
+  if (isSettledToolEvent(evidence)) delete action.fileReference;
+  if (evidence.fileReference) action.fileReference = evidence.fileReference;
   if (evidence.executorRole) action.executorRole = evidence.executorRole;
   if (evidence.roleCallId) action.roleCallId = evidence.roleCallId;
   if (isExecutedToolEvent(evidence)) action.executed = true;
@@ -109,9 +112,9 @@ function applyEvidence(action, evidence) {
     ]);
   }
   if (evidence.preview) action.preview = evidence.preview;
-  if (evidence.name === "tool.completed")
+  if (isSettledToolEvent(evidence))
     action.previewTruncated = evidence.previewTruncated;
-  if (evidence.name === "tool.completed") action.partial = evidence.partial;
+  if (isSettledToolEvent(evidence)) action.partial = evidence.partial;
 }
 
 function isExecutedToolEvent(evidence) {
@@ -152,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,
@@ -170,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,
@@ -185,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;
@@ -207,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>[];