@sentry/junior-dashboard 0.266.0 → 0.267.0

package/src/client/conversations/queries.ts

@@ -26,6 +26,7 @@ import {
   conversationEventPageSchema,
   conversationPendingMessagesReportSchema,
   forkConversationResponseSchema,
+  steerConversationPendingMessagesResponseSchema,
   stopConversationTurnResponseSchema,
 } from "@sentry/junior/api/schema";
 
@@ -42,8 +43,11 @@ import {
   conversationOutboxMessageForSubmit,
   conversationOutboxQueryKey,
   failConversationOutboxMessage,
+  isInlineOutboxMessage,
   mergeConversationMailboxMessages,
   acceptConversationOutboxMessage,
+  reuseConversationMailboxMessages,
+  splitInlineMailboxMessages,
   upsertConversationOutboxMessage,
   type ConversationMailboxMessage,
   type ConversationOutboxMessage,
@@ -130,6 +134,11 @@ export function usePendingArchiveConversationUpdates() {
   });
 }
 
+// Right after a send, Junior usually reads the message within a few seconds.
+// Poll fast for that window only, then fall back to the normal live interval.
+const FAST_POLL_INTERVAL_MS = 500;
+const FAST_POLL_WINDOW_MS = 6_000;
+
 type ConversationSnapshot = ConversationDetailReport & {
   mailbox?: ConversationPendingMessagesReport;
   detailEtag?: string;
@@ -149,7 +158,11 @@ async function readConversationSnapshot(
 /** Refresh history and mailbox as one visible snapshot, including idle input. */
 export function conversationDetailQueryOptions(
   conversationId: string | undefined,
-  options?: { awaitingMessage?: boolean },
+  options?: {
+    awaitingMessage?: boolean;
+    /** Poll fast until this time so a new send reaches history quickly. */
+    fastPollUntilMs?: number;
+  },
 ) {
   return queryOptions({
     enabled: Boolean(conversationId),
@@ -171,12 +184,14 @@ export function conversationDetailQueryOptions(
       );
     },
     refetchInterval: (query) =>
-      options?.awaitingMessage ||
-      query.state.data?.status === "active" ||
-      Boolean(query.state.data?.mailbox?.messages.length) ||
-      Boolean(query.state.data?.mailbox?.authorization)
-        ? 2_000
-        : 10_000,
+      options?.fastPollUntilMs && Date.now() < options.fastPollUntilMs
+        ? FAST_POLL_INTERVAL_MS
+        : options?.awaitingMessage ||
+            query.state.data?.status === "active" ||
+            Boolean(query.state.data?.mailbox?.messages.length) ||
+            Boolean(query.state.data?.mailbox?.authorization)
+          ? 2_000
+          : 10_000,
     retry: false,
   });
 }
@@ -213,6 +228,8 @@ export function useCreateConversation() {
             ...conversationOutboxMessageForSubmit({
               ...args,
               actorIdentity: outboxActorIdentity(queryClient),
+              // A new Conversation has no Turn or queue yet.
+              inline: true,
               messageId: accepted.messageId,
             }),
             status: "accepted",
@@ -261,6 +278,8 @@ export function useForkConversation(sourceConversationId: string) {
               idempotencyKey: args.idempotencyKey,
               message: args.message,
               actorIdentity: outboxActorIdentity(queryClient),
+              // A new fork has no Turn or queue yet.
+              inline: true,
               messageId: accepted.messageId,
             }),
             status: "accepted",
@@ -278,15 +297,20 @@ export function useAppendConversationMessage(conversationId: string) {
   const queryClient = useQueryClient();
   const outboxQueryKey = conversationOutboxQueryKey(conversationId);
   return useMutation({
-    mutationFn: (args: {
+    mutationFn: ({
+      inline: _inline,
+      ...body
+    }: {
       idempotencyKey: string;
+      /** Show the send in the transcript instead of the queue. */
+      inline?: boolean;
       message: string;
       images?: InputImage[];
     }) =>
       post(
         acceptedConversationMessageSchema,
         `/api/conversations/${encodeURIComponent(conversationId)}/messages`,
-        args,
+        body,
       ),
     onMutate: async (args) => {
       // Use the durable id from the first render. No server read is needed,
@@ -396,6 +420,52 @@ export function useCancelConversationPendingMessages(conversationId: string) {
   });
 }
 
+/** Ask Junior to read the viewer's own queued web messages now. */
+export function useSteerConversationPendingMessages(conversationId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (args: { inboundMessageIds: string[] }) =>
+      post(
+        steerConversationPendingMessagesResponseSchema,
+        `/api/conversations/${encodeURIComponent(conversationId)}/pending-messages/steer`,
+        args,
+      ),
+    onSuccess: async (result) => {
+      const steered = new Set(result.steeredInboundMessageIds);
+      if (steered.size === 0) return;
+      // A live poll that read the mailbox before the steer would restore
+      // `defer`. Cancel it; onSettled refetches after the write.
+      await queryClient.cancelQueries({
+        exact: true,
+        queryKey: conversationDetailQueryKey(conversationId),
+      });
+      queryClient.setQueryData<ConversationSnapshot>(
+        conversationDetailQueryKey(conversationId),
+        (current) =>
+          current?.mailbox
+            ? {
+                ...current,
+                mailbox: {
+                  ...current.mailbox,
+                  messages: current.mailbox.messages.map((message) =>
+                    steered.has(message.inboundMessageId)
+                      ? { ...message, delivery: "interrupt" as const }
+                      : message,
+                  ),
+                },
+              }
+            : current,
+      );
+    },
+    onSettled: async () => {
+      await queryClient.invalidateQueries({
+        exact: true,
+        queryKey: conversationDetailQueryKey(conversationId),
+      });
+    },
+  });
+}
+
 /**
  * Local cache of queued rows that a stop removed. The worker drops them only
  * when it observes the stop, so the mailbox can still list them for a while.
@@ -627,11 +697,20 @@ export function useConversationData(conversationId: string | undefined) {
     staleTime: Infinity,
     gcTime: Infinity,
   });
-  const awaitingMessage = outbox.data.some(
+  const awaitingRows = outbox.data.filter(
     (message) => message.status !== "failed",
   );
+  const latestSendAtMs = Math.max(
+    0,
+    ...awaitingRows.map((message) => Date.parse(message.createdAt)),
+  );
   const detail = useQuery(
-    conversationDetailQueryOptions(conversationId, { awaitingMessage }),
+    conversationDetailQueryOptions(conversationId, {
+      awaitingMessage: awaitingRows.length > 0,
+      fastPollUntilMs: latestSendAtMs
+        ? latestSendAtMs + FAST_POLL_WINDOW_MS
+        : undefined,
+    }),
   );
   // Defer the whole server snapshot, not history alone. Queue removal and the
   // matching transcript must paint together while composer input stays urgent.
@@ -647,17 +726,23 @@ export function useConversationData(conversationId: string | undefined) {
   // contains its real Message id. History and mailbox arrive in one render.
   useEffect(() => {
     if (!mailbox || !detailData) return;
-    const observedIds = new Set(
+    const queuedIds = new Set(
       mailbox.messages.map((message) => message.messageId),
     );
+    const historyIds = new Set<string>();
     for (const event of detailData.events) {
-      if (event.data.type === "message") observedIds.add(event.data.messageId);
+      if (event.data.type === "message") historyIds.add(event.data.messageId);
     }
     queryClient.setQueryData<ConversationOutboxMessage[]>(
       conversationOutboxQueryKey(conversationId),
       (current) => {
+        // An inline row stays until history has it. The mailbox copy alone
+        // would put it back in the queue.
         const next = current?.filter(
-          (message) => !observedIds.has(message.messageId),
+          (message) =>
+            !historyIds.has(message.messageId) &&
+            (isInlineOutboxMessage(message) ||
+              !queuedIds.has(message.messageId)),
         );
         return next?.length === current?.length ? current : next;
       },
@@ -727,23 +812,37 @@ export function useConversationData(conversationId: string | undefined) {
   const pendingMessagesRef = useRef<ConversationMailboxMessage[] | undefined>(
     undefined,
   );
-  const pendingMessages = useMemo(() => {
+  const inlineMessagesRef = useRef<ConversationMailboxMessage[] | undefined>(
+    undefined,
+  );
+  const { inlineMessages, pendingMessages } = useMemo(() => {
     // Hide stopped rows from both sources, or the outbox copy of a stopped
     // send would look unseen and come back.
     const stopped = stoppedMessageIds.data;
-    const next = mergeConversationMailboxMessages(
-      stopped.length
-        ? mailbox?.messages.filter(
-            (message) => !stopped.includes(message.inboundMessageId),
-          )
-        : mailbox?.messages,
-      stopped.length
-        ? outbox.data.filter((message) => !stopped.includes(message.messageId))
-        : outbox.data,
+    const server = stopped.length
+      ? mailbox?.messages.filter(
+          (message) => !stopped.includes(message.inboundMessageId),
+        )
+      : mailbox?.messages;
+    const local = stopped.length
+      ? outbox.data.filter((message) => !stopped.includes(message.messageId))
+      : outbox.data;
+    const split = splitInlineMailboxMessages(
+      mergeConversationMailboxMessages(server, local),
+      server,
+      local,
+    );
+    const queued = reuseConversationMailboxMessages(
       pendingMessagesRef.current,
+      split.queued,
+    );
+    const inline = reuseConversationMailboxMessages(
+      inlineMessagesRef.current,
+      split.inline,
     );
-    pendingMessagesRef.current = next;
-    return next;
+    pendingMessagesRef.current = queued;
+    inlineMessagesRef.current = inline;
+    return { inlineMessages: inline, pendingMessages: queued };
   }, [outbox.data, mailbox?.messages, stoppedMessageIds.data]);
   const invalidHistoryCursor = isInvalidCursorError(history.error);
   const shouldRefreshDetail = Boolean(
@@ -797,6 +896,8 @@ export function useConversationData(conversationId: string | undefined) {
     isLoadingPreviousPage,
     pendingAuthorization: mailbox?.authorization,
     pendingGeneratedAt: mailbox?.generatedAt,
+    /** The reader's own sends that the transcript shows before history has them. */
+    inlineMessages,
     pendingMessages,
     loadCompleteTranscript: () => {
       if (!conversationId || !detailData) {

package/src/client/conversations/transcriptMarkdownLinks.ts

@@ -1,331 +1,11 @@
 export const TRANSCRIPT_ANCHOR_CLASS =
   "font-medium text-dashboard-accent-text underline decoration-dashboard-accent/35 underline-offset-2 transition-colors hover:text-dashboard-text hover:decoration-dashboard-text-solid";
 
-export type TranscriptMarkdownLink = {
-  end: number;
-  href: string;
-  label: string;
-  start: number;
-};
-
-type TextRange = {
-  end: number;
-  start: number;
-};
-
-/** Find safe markdown and bare links that should become transcript anchors. */
-export function findTranscriptMarkdownLinks(
-  text: string,
-): TranscriptMarkdownLink[] {
-  const literalRanges = findLiteralRanges(text);
-  const markdownSyntaxRanges = findMarkdownLinkSyntaxRanges(
-    text,
-    literalRanges,
-  );
-  const markdownLinks = findMarkdownLinks(text, literalRanges);
-  const autolinks = findCommonMarkAutolinks(
-    text,
-    mergeRanges([...literalRanges, ...markdownSyntaxRanges]),
-  );
-  const bareRanges = mergeRanges([
-    ...literalRanges,
-    ...markdownSyntaxRanges,
-    ...autolinks,
-  ]);
-  return [
-    ...markdownLinks,
-    ...autolinks,
-    ...findBareLinks(text, bareRanges),
-  ].sort((left, right) => left.start - right.start || left.end - right.end);
-}
-
-function findMarkdownLinks(
-  text: string,
-  ignoredRanges: TextRange[],
-): TranscriptMarkdownLink[] {
-  const links: TranscriptMarkdownLink[] = [];
-  let cursor = 0;
-  while (cursor < text.length) {
-    const link = findNextMarkdownLink(text, cursor, ignoredRanges);
-    if (!link) break;
-    links.push(link);
-    cursor = link.end;
-  }
-  return links;
-}
-
-function findNextMarkdownLink(
-  text: string,
-  start: number,
-  ignoredRanges: TextRange[],
-): TranscriptMarkdownLink | undefined {
-  for (
-    let linkStart = text.indexOf("[", start);
-    linkStart >= 0;
-    linkStart = text.indexOf("[", linkStart + 1)
-  ) {
-    if (isInRange(linkStart, ignoredRanges) || isEscaped(text, linkStart)) {
-      continue;
-    }
-
-    const labelEnd = text.indexOf("]", linkStart + 1);
-    if (labelEnd < 0) return undefined;
-    if (text[labelEnd + 1] !== "(") continue;
-
-    const label = text.slice(linkStart + 1, labelEnd);
-    if (!isMarkdownLinkLabel(label)) continue;
-
-    const destination = readMarkdownDestination(text, labelEnd + 2);
-    if (!destination) continue;
-
-    const href = safeMarkdownDestinationHref(destination.href);
-    if (!href) continue;
-
-    return {
-      end: destination.end,
-      href,
-      label,
-      start: linkStart,
-    };
-  }
-  return undefined;
-}
-
-function findMarkdownLinkSyntaxRanges(
-  text: string,
-  ignoredRanges: TextRange[],
-): TextRange[] {
-  const ranges: TextRange[] = [];
-  for (
-    let linkStart = text.indexOf("[");
-    linkStart >= 0;
-    linkStart = text.indexOf("[", linkStart + 1)
-  ) {
-    if (isInRange(linkStart, ignoredRanges) || isEscaped(text, linkStart)) {
-      continue;
-    }
-
-    const labelEnd = text.indexOf("]", linkStart + 1);
-    if (labelEnd < 0) continue;
-    if (text[labelEnd + 1] !== "(") continue;
-
-    const label = text.slice(linkStart + 1, labelEnd);
-    if (!isMarkdownLinkLabel(label)) continue;
-
-    const destination = readMarkdownDestination(text, labelEnd + 2);
-    if (!destination) continue;
-
-    ranges.push({ start: linkStart, end: destination.end });
-  }
-  return ranges;
-}
-
-function isMarkdownLinkLabel(label: string): boolean {
-  return Boolean(label) && !label.includes("\n") && !label.includes("[");
-}
-
-function readMarkdownDestination(
-  text: string,
-  start: number,
-): { end: number; href: string } | undefined {
-  let depth = 0;
-  for (let index = start; index < text.length; index += 1) {
-    const char = text[index];
-    if (char === "\\") {
-      index += 1;
-      continue;
-    }
-    if (char === "(") {
-      depth += 1;
-      continue;
-    }
-    if (char !== ")") continue;
-
-    if (depth > 0) {
-      depth -= 1;
-      continue;
-    }
-
-    const href = text.slice(start, index);
-    return href ? { end: index + 1, href } : undefined;
-  }
-  return undefined;
-}
-
-function findCommonMarkAutolinks(
-  text: string,
-  ignoredRanges: TextRange[],
-): TranscriptMarkdownLink[] {
-  const links: TranscriptMarkdownLink[] = [];
-  const pattern = /<(https?:\/\/[^<>\s]+|mailto:[^<>\s]+)>/gi;
-  let match: RegExpExecArray | null;
-
-  while ((match = pattern.exec(text))) {
-    if (isInRange(match.index, ignoredRanges) || isEscaped(text, match.index)) {
-      continue;
-    }
-    const href = safeLinkHref(match[1] ?? "");
-    if (!href) continue;
-    links.push({
-      end: match.index + match[0].length,
-      href,
-      label: href,
-      start: match.index,
-    });
-  }
-  return links;
-}
-
-function findNextBareLink(
-  text: string,
-  start: number,
-  ignoredRanges: TextRange[],
-): TranscriptMarkdownLink | undefined {
-  // Stop at * so emphasis markers stay outside the URL, matching Slack outbound
-  // bare-URL wrapping (`readBareUrl` in packages/junior/src/chat/slack/mrkdwn.ts).
-  const bareUrlPattern = /(https?:\/\/[^\s<>"'*]+|mailto:[^\s<>"'*]+)/gi;
-  bareUrlPattern.lastIndex = start;
-
-  let match: RegExpExecArray | null;
-  while ((match = bareUrlPattern.exec(text))) {
-    if (isInRange(match.index, ignoredRanges)) continue;
-
-    const bareLink = trimBareUrl(match[0]);
-    const href = safeLinkHref(bareLink);
-    if (!href) continue;
-
-    return {
-      end: match.index + bareLink.length,
-      href,
-      label: href,
-      start: match.index,
-    };
-  }
-  return undefined;
-}
-
-function findBareLinks(
-  text: string,
-  ignoredRanges: TextRange[],
-): TranscriptMarkdownLink[] {
-  const links: TranscriptMarkdownLink[] = [];
-  let cursor = 0;
-  while (cursor < text.length) {
-    const link = findNextBareLink(text, cursor, ignoredRanges);
-    if (!link) break;
-    links.push(link);
-    cursor = link.end;
-  }
-  return links;
-}
-
-function findLiteralRanges(text: string): TextRange[] {
-  return [...findInlineCodeRanges(text), ...findEscapedMarkdownLinkRanges(text)]
-    .filter((range) => range.end > range.start)
-    .sort((left, right) => left.start - right.start || left.end - right.end);
-}
-
-function findInlineCodeRanges(text: string): TextRange[] {
-  const ranges: TextRange[] = [];
-  for (let index = 0; index < text.length; index += 1) {
-    if (text[index] !== "`" || isEscaped(text, index)) continue;
-
-    const ticks = countRun(text, index, "`");
-    const closing = findClosingBacktickRun(text, index + ticks, ticks);
-    if (closing < 0) {
-      index += ticks - 1;
-      continue;
-    }
-
-    ranges.push({ start: index, end: closing + ticks });
-    index = closing + ticks - 1;
-  }
-  return ranges;
-}
-
-function findClosingBacktickRun(
-  text: string,
-  start: number,
-  ticks: number,
-): number {
-  for (let index = start; index < text.length; index += 1) {
-    if (text[index] !== "`" || isEscaped(text, index)) continue;
-
-    const run = countRun(text, index, "`");
-    if (run === ticks) return index;
-    index += run - 1;
-  }
-  return -1;
-}
-
-function findEscapedMarkdownLinkRanges(text: string): TextRange[] {
-  const ranges: TextRange[] = [];
-  for (
-    let linkStart = text.indexOf("[");
-    linkStart >= 0;
-    linkStart = text.indexOf("[", linkStart + 1)
-  ) {
-    if (!isEscaped(text, linkStart)) continue;
-
-    const labelEnd = text.indexOf("]", linkStart + 1);
-    if (labelEnd < 0) continue;
-    if (text[labelEnd + 1] !== "(") continue;
-
-    const destination = readMarkdownDestination(text, labelEnd + 2);
-    if (!destination) continue;
-
-    ranges.push({ start: linkStart, end: destination.end });
-  }
-  return ranges;
-}
-
-function isInRange(index: number, ranges: TextRange[]): boolean {
-  for (const range of ranges) {
-    if (index < range.start) return false;
-    if (index >= range.start && index < range.end) return true;
-  }
-  return false;
-}
-
-function isEscaped(text: string, index: number): boolean {
-  let backslashes = 0;
-  for (
-    let cursor = index - 1;
-    cursor >= 0 && text[cursor] === "\\";
-    cursor -= 1
-  ) {
-    backslashes += 1;
-  }
-  return backslashes % 2 === 1;
-}
-
-function countRun(text: string, start: number, char: string): number {
-  let count = 0;
-  for (
-    let index = start;
-    index < text.length && text[index] === char;
-    index += 1
-  ) {
-    count += 1;
-  }
-  return count;
-}
-
-function safeMarkdownDestinationHref(destination: string): string | undefined {
-  const href = readMarkdownHref(destination);
-  return href ? safeLinkHref(href) : undefined;
-}
-
-function readMarkdownHref(destination: string): string | undefined {
-  const trimmed = destination.trim();
-  const match =
-    /^(<[^>\n]+>|[^\s]+)(?:\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?$/.exec(trimmed);
-  const href = match?.[1];
-  if (!href) return undefined;
-  return href.startsWith("<") && href.endsWith(">") ? href.slice(1, -1) : href;
-}
-
-function safeLinkHref(href: string): string | undefined {
+/**
+ * Keep a transcript link destination only when it is an absolute `http:`,
+ * `https:`, or `mailto:` URL. Return undefined to drop the link.
+ */
+export function safeTranscriptHref(href: string): string | undefined {
   const trimmed = href.trim();
   const hasControlCharacter = [...trimmed].some((character) => {
     const code = character.charCodeAt(0);
@@ -343,45 +23,3 @@ function safeLinkHref(href: string): string | undefined {
     return undefined;
   }
 }
-
-function trimBareUrl(href: string): string {
-  let trimmed = href;
-
-  while (shouldTrimBareUrlSuffix(trimmed)) {
-    trimmed = trimmed.slice(0, -1);
-  }
-
-  return trimmed;
-}
-
-function shouldTrimBareUrlSuffix(href: string): boolean {
-  const last = href.at(-1);
-  if (!last) return false;
-  if (/[.,;:!?]/.test(last)) return true;
-  return last === ")" && closingParensExceedOpening(href);
-}
-
-function closingParensExceedOpening(value: string): boolean {
-  let balance = 0;
-  for (const char of value) {
-    if (char === "(") balance += 1;
-    if (char === ")") balance -= 1;
-  }
-  return balance < 0;
-}
-
-function mergeRanges(ranges: TextRange[]): TextRange[] {
-  const sorted = ranges
-    .filter((range) => range.end > range.start)
-    .sort((left, right) => left.start - right.start || left.end - right.end);
-  const merged: TextRange[] = [];
-  for (const range of sorted) {
-    const previous = merged.at(-1);
-    if (!previous || range.start > previous.end) {
-      merged.push({ ...range });
-      continue;
-    }
-    previous.end = Math.max(previous.end, range.end);
-  }
-  return merged;
-}

package/src/client/conversations/userInputRequest.ts

@@ -0,0 +1,56 @@
+import {
+  userInputRequestSchema,
+  type ConversationReportEvent,
+  type UserInputRequest,
+} from "@sentry/junior/api/schema";
+
+/** Model-facing name of Junior's tool that asks a person for input. */
+const REQUEST_USER_INPUT_TOOL_NAME = "requestUserInput";
+
+/** A request from Junior that still waits for an answer. */
+export type OpenUserInputRequest = UserInputRequest & { toolCallId: string };
+
+/**
+ * Find the latest `requestUserInput` call that no user message answers yet.
+ * Any later user message is the answer, whether it is a submitted form or
+ * typed text.
+ *
+ * Reporting splits one call over events: the assistant event has the input
+ * and status `running`, and the later result event has status `completed`
+ * without the input. Keep the input by tool call id until the result.
+ */
+export function openUserInputRequest(
+  events: readonly ConversationReportEvent[] | undefined,
+): OpenUserInputRequest | undefined {
+  const inputs = new Map<string, unknown>();
+  const completed = new Set<string>();
+  let open: OpenUserInputRequest | undefined;
+  for (const event of events ?? []) {
+    const data = event.data;
+    if (data.type === "message" && data.role === "user") {
+      open = undefined;
+      continue;
+    }
+    if (data.type !== "tool_calls") continue;
+    for (const call of data.calls) {
+      if (call.name !== REQUEST_USER_INPUT_TOOL_NAME) continue;
+      if (call.input !== undefined) inputs.set(call.toolCallId, call.input);
+      if (call.status === "error" && open?.toolCallId === call.toolCallId) {
+        open = undefined;
+      }
+      // Open a request once, when its result first arrives. A repeated
+      // result must not reopen a request that a user message answered.
+      if (call.status !== "completed" || completed.has(call.toolCallId)) {
+        continue;
+      }
+      completed.add(call.toolCallId);
+      const request = userInputRequestSchema.safeParse(
+        inputs.get(call.toolCallId),
+      );
+      if (request.success) {
+        open = { ...request.data, toolCallId: call.toolCallId };
+      }
+    }
+  }
+  return open;
+}