@sentry/junior 0.90.0 → 0.91.0

package/dist/app.js

@@ -104,7 +104,7 @@ import {
   shouldPropagateSandboxEgressTrace,
   startOAuthFlow,
   unlinkProvider
-} from "./chunk-BKSZL4QO.js";
+} from "./chunk-ZGDTBSQ7.js";
 import {
   CooperativeTurnYieldError,
   TurnInputCommitLostError,
@@ -139,11 +139,13 @@ import {
 import "./chunk-5GBUZI6M.js";
 import {
   buildSlackOutputMessage,
+  escapeSlackMrkdwnText,
+  formatSlackLink,
   normalizeSlackStatusText,
   splitSlackReplyText,
   truncateStatusText,
   unwrapCurrentInstruction
-} from "./chunk-PHZHJTCK.js";
+} from "./chunk-PIB4EOW6.js";
 import {
   abandonAgentTurnSessionRecord,
   commitMessages,
@@ -321,12 +323,6 @@ function getDashboardConversationLink(conversationId) {
 }
 
 // src/chat/slack/footer.ts
-function escapeSlackMrkdwn(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function escapeSlackLinkUrl(url) {
-  return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
-}
 function buildSlackReplyFooter(args) {
   const items = [];
   const conversationId = args.conversationId?.trim();
@@ -358,7 +354,7 @@ function buildSlackReplyBlocks(text, footer) {
       type: "context",
       elements: footer.items.map((item) => ({
         type: "mrkdwn",
-        text: item.url ? `*${escapeSlackMrkdwn(item.label)}:* <${escapeSlackLinkUrl(item.url)}|${escapeSlackMrkdwn(item.value)}>` : `*${escapeSlackMrkdwn(item.label)}:* ${escapeSlackMrkdwn(item.value)}`
+        text: item.url ? `*${escapeSlackMrkdwnText(item.label)}:* ${formatSlackLink(item.url, item.value)}` : `*${escapeSlackMrkdwnText(item.label)}:* ${escapeSlackMrkdwnText(item.value)}`
       }))
     });
   }
@@ -7521,7 +7517,7 @@ function getQueuedMessages(context, options) {
       stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
     });
     return {
-      explicitMention: options.explicitMention || Boolean(message.isMention),
+      explicitMention: Boolean(message.isMention),
       message,
       rawText: appendSlackLegacyAttachmentText(message.text, message.raw),
       userText: appendSlackLegacyAttachmentText(stripped, message.raw)
@@ -9284,6 +9280,56 @@ function parkedInputKey(message) {
   const text = first && typeof first === "object" && "text" in first ? String(first.text ?? "") : "";
   return `${message.timestamp}:${text}`;
 }
+function renderRecentThreadMessages(conversationContext, messages) {
+  const passiveMessages = messages.filter((queued) => {
+    if (queued.explicitMention) {
+      return false;
+    }
+    const slackTs = queuedInstructionActor(queued)?.slackTs;
+    return !slackTs || !conversationContext?.includes(`slack_ts="${slackTs}"`);
+  });
+  if (passiveMessages.length === 0) {
+    return void 0;
+  }
+  const lines = ["<recent-thread-messages>"];
+  for (const queued of passiveMessages) {
+    const actor = queuedInstructionActor(queued);
+    const attrs = [
+      actor?.authorId ? `author_id="${escapeXml(actor.authorId)}"` : void 0,
+      actor?.authorName ? `author_name="${escapeXml(actor.authorName)}"` : void 0,
+      actor?.slackTs ? `slack_ts="${escapeXml(actor.slackTs)}"` : void 0
+    ].filter((attr) => Boolean(attr)).join(" ");
+    lines.push(
+      attrs ? `  <message ${attrs}>` : "  <message>",
+      escapeXml(queued.userText),
+      "  </message>"
+    );
+  }
+  lines.push("</recent-thread-messages>");
+  return lines.join("\n");
+}
+function appendRecentThreadMessagesToContext(conversationContext, messages, options) {
+  const recentThreadMessages = renderRecentThreadMessages(
+    conversationContext,
+    messages
+  );
+  const contextParts = [
+    options?.includeConversationContext === false ? void 0 : conversationContext?.trim(),
+    recentThreadMessages
+  ].filter((part) => Boolean(part));
+  return contextParts.length > 0 ? contextParts.join("\n\n") : void 0;
+}
+function queuedInstructionActor(queued) {
+  const actor = getMessageActorIdentity(queued.message);
+  const authorId = actor?.userId ?? parseActorUserId(queued.message.author.userId);
+  const authorName = actor?.fullName ?? actor?.userName;
+  const slackTs = getSlackMessageTs(queued.message);
+  return {
+    ...authorId ? { authorId } : {},
+    ...authorName ? { authorName } : {},
+    ...slackTs ? { slackTs } : {}
+  };
+}
 function isResourceEventMessage(message) {
   const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
   return raw?.event_type === "resource_event";
@@ -9407,10 +9453,6 @@ function createReplyToThread(deps) {
             message.raw
           )
         };
-        const effectiveUserText = combineTurnText(
-          options.queuedMessages ?? [],
-          currentText
-        ).userText;
         await Promise.all(
           (options.queuedMessages ?? []).filter((queued) => !isResourceEventMessage(queued.message)).map(
             (queued) => ensureSlackMessageActorIdentity(
@@ -9420,6 +9462,7 @@ function createReplyToThread(deps) {
             )
           )
         );
+        const effectiveUserText = currentText.userText;
         const credentialContext = resourceEventCredentialContext(message) ?? {
           actor: { type: "user", userId: message.author.userId }
         };
@@ -9511,6 +9554,7 @@ function createReplyToThread(deps) {
             queuedMessages.map(async (queued) => {
               const attachments = queued.message.attachments;
               return {
+                actor: queuedInstructionActor(queued),
                 text: queued.userText,
                 timestampMs: queued.message.metadata.dateSent.getTime(),
                 omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
@@ -9861,6 +9905,18 @@ function createReplyToThread(deps) {
               });
             }
           }
+          const hasDurablePromptHistory = Boolean(piMessages?.length);
+          const queuedInstructionPiMessages = (await resolveSteeringMessages(
+            (options.queuedMessages ?? []).filter(
+              (queued) => queued.explicitMention
+            )
+          )).map(buildSteeringPiMessage);
+          if (queuedInstructionPiMessages.length > 0) {
+            piMessages = [
+              ...piMessages ?? [],
+              ...queuedInstructionPiMessages
+            ];
+          }
           status.start();
           const assistantTitleTask = maybeUpdateAssistantTitle({
             assistantThreadContext,
@@ -9924,6 +9980,12 @@ function createReplyToThread(deps) {
             );
           });
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
+          const activeInstructionAuthorId = requester?.userId ?? parseActorUserId(message.author.userId);
+          const activeInstructionAuthorName = requester?.fullName ?? requester?.userName;
+          const promptConversationContext = appendRecentThreadMessagesToContext(
+            preparedState.conversationContext,
+            options.queuedMessages ?? []
+          );
           const drainSteeringMessages = options.drainSteeringMessages ? async (accept) => {
             let acceptedMessages;
             const drained = await options.drainSteeringMessages(
@@ -9937,8 +9999,14 @@ function createReplyToThread(deps) {
           } : void 0;
           const outcome = await deps.services.agentRunner.run({
             input: {
+              actor: {
+                ...activeInstructionAuthorId ? { authorId: activeInstructionAuthorId } : {},
+                ...activeInstructionAuthorName ? { authorName: activeInstructionAuthorName } : {},
+                ...slackMessageTs ? { slackTs: slackMessageTs } : {}
+              },
+              includeConversationContextWithPiMessages: hasDurablePromptHistory,
               messageText: effectiveUserText,
-              conversationContext: preparedState.conversationContext,
+              conversationContext: promptConversationContext,
               piMessages,
               inboundAttachmentCount: turnAttachments.length,
               omittedImageAttachmentCount,

package/dist/chat/agent/prompt.d.ts

@@ -7,7 +7,7 @@ import type { ToolRuntimeContext } from "@/chat/tools/types";
 import type { AnyToolDefinition } from "@/chat/tools/definition";
 import type { Requester } from "@/chat/requester";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
-import type { AgentRunInput, AgentRunRouting, AgentRunSteeringMessage } from "@/chat/agent/request";
+import type { AgentRunInput, AgentRunInstructionActor, AgentRunRouting, AgentRunSteeringMessage } from "@/chat/agent/request";
 export type UserContentPart = {
     type: "text";
     text: string;
@@ -36,7 +36,7 @@ export interface PromptAssembly {
 /**
  * Keep thread text separate from the canonical active task boundary.
  */
-export declare function buildUserTurnText(userInput: string, conversationContext?: string): string;
+export declare function buildUserTurnText(userInput: string, conversationContext?: string, actor?: AgentRunInstructionActor): string;
 /** Encode a non-image attachment as base64 XML for the prompt. */
 export declare function encodeNonImageAttachmentForPrompt(attachment: {
     data: Buffer;

package/dist/chat/agent/request.d.ts

@@ -28,7 +28,13 @@ export interface AgentRunAttachment {
     filename?: string;
     promptText?: string;
 }
+export interface AgentRunInstructionActor {
+    authorId?: string;
+    authorName?: string;
+    slackTs?: string;
+}
 export interface AgentRunSteeringMessage {
+    actor?: AgentRunInstructionActor;
     omittedImageAttachmentCount?: number;
     text: string;
     timestampMs?: number;
@@ -36,6 +42,8 @@ export interface AgentRunSteeringMessage {
 }
 /** Carries the user-visible content and prior transcript for one agent-run slice. */
 export interface AgentRunInput {
+    actor?: AgentRunInstructionActor;
+    includeConversationContextWithPiMessages?: boolean;
     messageText: string;
     userAttachments?: AgentRunAttachment[];
     inboundAttachmentCount?: number;

package/dist/chat/current-instruction.d.ts

@@ -1,6 +1,8 @@
 /** Render the active user task in a stable prompt boundary. */
-export declare function renderCurrentInstruction(instruction: string): string;
-/** Read the exact body from a standalone current-task prompt boundary. */
-export declare function extractCurrentInstructionBody(text: string): string | undefined;
+export declare function renderCurrentInstruction(instruction: string, attrs?: {
+    authorId?: string;
+    authorName?: string;
+    slackTs?: string;
+}): string;
 /** Recover display text from the internal current-task prompt boundary. */
 export declare function unwrapCurrentInstruction(text: string): string | undefined;

package/dist/chat/oauth-authorization-message.d.ts

@@ -0,0 +1,6 @@
+/** Format the private OAuth authorization prompt for Slack delivery. */
+export declare function formatOAuthAuthorizationMessage(args: {
+    authorizationUrl: string;
+    label: string;
+    completionText: string;
+}): string;

package/dist/chat/slack/mrkdwn.d.ts

@@ -1,3 +1,9 @@
+/** Escape dynamic text for Slack mrkdwn without changing intended formatting. */
+export declare function escapeSlackMrkdwnText(text: string): string;
+/** Escape a URL for Slack explicit link syntax while preserving query semantics. */
+export declare function escapeSlackLinkUrl(url: string): string;
+/** Build a Slack explicit link from dynamic URL and label values. */
+export declare function formatSlackLink(url: string, label: string): string;
 /** Insert blank lines between content blocks so Slack renders them with visual separation. */
 export declare function ensureBlockSpacing(text: string): string;
 /**

package/dist/{chunk-PHZHJTCK.js → chunk-PIB4EOW6.js}

@@ -23,32 +23,53 @@ import {
 
 // src/chat/current-instruction.ts
 var CURRENT_INSTRUCTION_TAG = "current-instruction";
-var CURRENT_INSTRUCTION_PATTERN = new RegExp(
-  `<${CURRENT_INSTRUCTION_TAG}>\\n([\\s\\S]*?)\\n</${CURRENT_INSTRUCTION_TAG}>`
-);
-var STANDALONE_CURRENT_INSTRUCTION_PATTERN = new RegExp(
-  `^<${CURRENT_INSTRUCTION_TAG}>\\n([\\s\\S]*?)\\n</${CURRENT_INSTRUCTION_TAG}>$`
-);
+var CURRENT_INSTRUCTION_OPEN_PREFIX = `<${CURRENT_INSTRUCTION_TAG}`;
+var CURRENT_INSTRUCTION_OPEN_BARE = `<${CURRENT_INSTRUCTION_TAG}>`;
+var CURRENT_INSTRUCTION_OPEN_ATTR_PREFIX = `<${CURRENT_INSTRUCTION_TAG} `;
+var CURRENT_INSTRUCTION_CLOSE = `
+</${CURRENT_INSTRUCTION_TAG}>`;
 function unescapeXml(value) {
   return value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
 }
-function renderCurrentInstruction(instruction) {
+function isCurrentInstructionOpeningTag(value) {
+  return value === CURRENT_INSTRUCTION_OPEN_BARE || value.startsWith(CURRENT_INSTRUCTION_OPEN_ATTR_PREFIX) && value.endsWith(">");
+}
+function readCurrentInstructionBody(text) {
+  const start = text.indexOf(CURRENT_INSTRUCTION_OPEN_PREFIX);
+  if (start < 0) {
+    return void 0;
+  }
+  const openingEnd = text.indexOf(">\n", start);
+  if (openingEnd < 0) {
+    return void 0;
+  }
+  const openingTag = text.slice(start, openingEnd + 1);
+  if (!isCurrentInstructionOpeningTag(openingTag)) {
+    return void 0;
+  }
+  const bodyStart = openingEnd + 2;
+  const bodyEnd = text.indexOf(CURRENT_INSTRUCTION_CLOSE, bodyStart);
+  if (bodyEnd < bodyStart) {
+    return void 0;
+  }
+  return text.slice(bodyStart, bodyEnd);
+}
+function renderCurrentInstruction(instruction, attrs) {
+  const renderedAttrs = [
+    attrs?.authorId ? `author_id="${escapeXml(attrs.authorId)}"` : void 0,
+    attrs?.authorName ? `author_name="${escapeXml(attrs.authorName)}"` : void 0,
+    attrs?.slackTs ? `slack_ts="${escapeXml(attrs.slackTs)}"` : void 0
+  ].filter((attr) => Boolean(attr)).join(" ");
+  const openingTag = renderedAttrs ? `<${CURRENT_INSTRUCTION_TAG} ${renderedAttrs}>` : `<${CURRENT_INSTRUCTION_TAG}>`;
   return [
-    `<${CURRENT_INSTRUCTION_TAG}>`,
+    openingTag,
     escapeXml(instruction),
     `</${CURRENT_INSTRUCTION_TAG}>`
   ].join("\n");
 }
-function extractCurrentInstructionBody(text) {
-  const match = text.match(STANDALONE_CURRENT_INSTRUCTION_PATTERN);
-  return match?.[1];
-}
 function unwrapCurrentInstruction(text) {
-  const match = text.match(CURRENT_INSTRUCTION_PATTERN);
-  if (!match) {
-    return void 0;
-  }
-  return unescapeXml(match[1]);
+  const body = readCurrentInstructionBody(text);
+  return body === void 0 ? void 0 : unescapeXml(body);
 }
 
 // src/chat/prompt.ts
@@ -81,6 +102,15 @@ function truncateStatusText(text) {
 }
 
 // src/chat/slack/mrkdwn.ts
+function escapeSlackMrkdwnText(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeSlackLinkUrl(url) {
+  return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
+}
+function formatSlackLink(url, label) {
+  return `<${escapeSlackLinkUrl(url)}|${escapeSlackMrkdwnText(label)}>`;
+}
 function readInlineCodeSpan(line, start) {
   if (line[start] !== "`") {
     return void 0;
@@ -1049,9 +1079,10 @@ export {
   containsNoReplyMarker,
   stripNoReplyMarker,
   renderCurrentInstruction,
-  extractCurrentInstructionBody,
   unwrapCurrentInstruction,
   truncateStatusText,
+  escapeSlackMrkdwnText,
+  formatSlackLink,
   normalizeSlackStatusText,
   splitSlackReplyText,
   buildSlackOutputMessage,