@sentry/junior 0.24.0 → 0.24.1

package/dist/app.js

@@ -6,7 +6,7 @@ import {
   loadSkillsByName,
   logCapabilityCatalogLoadedOnce,
   parseSkillInvocation
-} from "./chunk-DGN3WLA4.js";
+} from "./chunk-O5N42P7K.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -27,7 +27,7 @@ import {
   sandboxSkillDir,
   sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-B5O2EJUV.js";
+} from "./chunk-RMVXZMXQ.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -35,6 +35,7 @@ import {
   createPluginBroker,
   createRequestContext,
   extractGenAiUsageAttributes,
+  extractGenAiUsageSummary,
   getActiveTraceId,
   getPluginDefinition,
   getPluginMcpProviders,
@@ -58,7 +59,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-J7JEFMVD.js";
+} from "./chunk-I3WA75AD.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -1082,6 +1083,9 @@ async function postSlackMessage(input) {
       channel: channelId,
       text,
       mrkdwn: true,
+      ...input.blocks?.length ? {
+        blocks: input.blocks
+      } : {},
       ...threadTs ? { thread_ts: threadTs } : {}
     }),
     3,
@@ -1100,6 +1104,24 @@ async function postSlackMessage(input) {
     } : {}
   };
 }
+async function deleteSlackMessage(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack message deletion"
+  );
+  const timestamp = requireSlackMessageTimestamp(
+    input.timestamp,
+    "Slack message deletion"
+  );
+  await withSlackRetries(
+    () => getSlackClient().chat.delete({
+      channel: channelId,
+      ts: timestamp
+    }),
+    3,
+    { action: "chat.delete" }
+  );
+}
 async function postSlackEphemeralMessage(input) {
   const channelId = requireSlackConversationId(
     input.channelId,
@@ -3212,6 +3234,9 @@ function appendSlackSuffix(text, marker) {
   const carryover = getFenceContinuation(text);
   return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
 }
+function stripTrailingContinuationMarker(text) {
+  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
+}
 function takeSlackContinuationChunk(text, budget) {
   let { prefix, rest } = takeSlackInlinePrefix(text, budget);
   if (!rest) {
@@ -3309,6 +3334,9 @@ function splitSlackReplyText(text, options) {
     chunks.push(renderedPrefix);
     remaining = rest;
   }
+  if (chunks.length === 2) {
+    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+  }
   return chunks;
 }
 function getSlackContinuationBudget() {
@@ -9762,8 +9790,10 @@ function buildTurnResult(input) {
     toolCalls,
     sandboxId,
     sandboxDependencyProfileHash,
+    durationMs,
     shouldTrace,
     spanContext,
+    usage,
     correlation,
     assistantUserName
   } = input;
@@ -9838,6 +9868,8 @@ function buildTurnResult(input) {
     toolResultCount: toolResults.length,
     toolErrorCount,
     usedPrimaryText,
+    durationMs,
+    usage,
     stopReason,
     errorMessage,
     providerError: void 0
@@ -10156,6 +10188,7 @@ function mcpToolsToDefinitions(mcpTools) {
   return defs;
 }
 async function generateAssistantReply(messageText, context = {}) {
+  const replyStartedAtMs = Date.now();
   let timeoutResumeConversationId;
   let timeoutResumeSessionId;
   let timeoutResumeSliceId = 1;
@@ -10166,6 +10199,7 @@ async function generateAssistantReply(messageText, context = {}) {
   let mcpToolManager;
   let sandboxExecutor;
   let timedOut = false;
+  let turnUsage;
   const getSandboxMetadata = () => sandboxExecutor ? {
     sandboxId: sandboxExecutor.getSandboxId(),
     sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
@@ -10684,14 +10718,16 @@ async function generateAssistantReply(messageText, context = {}) {
           }
           const outputMessages = newMessages.filter(isAssistantMessage);
           const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
-          const usageAttributes = extractGenAiUsageAttributes(
+          const usageSummary = extractGenAiUsageSummary(
             promptResult,
             agent.state,
             ...outputMessages
           );
+          turnUsage = usageSummary.inputTokens !== void 0 || usageSummary.outputTokens !== void 0 || usageSummary.totalTokens !== void 0 ? usageSummary : void 0;
           setSpanAttributes({
             ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
-            ...usageAttributes
+            ...usageSummary.inputTokens !== void 0 ? { "gen_ai.usage.input_tokens": usageSummary.inputTokens } : {},
+            ...usageSummary.outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": usageSummary.outputTokens } : {}
           });
         },
         {
@@ -10724,9 +10760,11 @@ async function generateAssistantReply(messageText, context = {}) {
       toolCalls,
       sandboxId: currentSandboxExecutor.getSandboxId(),
       sandboxDependencyProfileHash: currentSandboxExecutor.getDependencyProfileHash(),
+      durationMs: Date.now() - replyStartedAtMs,
       generatedFileCount: generatedFiles.length,
       shouldTrace,
       spanContext,
+      usage: turnUsage,
       correlation: context.correlation,
       assistantUserName: context.assistant?.userName
     });
@@ -10817,6 +10855,7 @@ async function generateAssistantReply(messageText, context = {}) {
         toolResultCount: 0,
         toolErrorCount: 0,
         usedPrimaryText: false,
+        durationMs: Date.now() - replyStartedAtMs,
         errorMessage: message,
         providerError: error
       }
@@ -10837,6 +10876,86 @@ async function generateAssistantReply(messageText, context = {}) {
   }
 }
 
+// src/chat/slack/footer.ts
+function escapeSlackMrkdwn(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function formatSlackTokenCount(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatSlackDuration(durationMs) {
+  if (durationMs < 1e3) {
+    return `${durationMs}ms`;
+  }
+  const durationSeconds = durationMs / 1e3;
+  if (durationSeconds < 10) {
+    return `${durationSeconds.toFixed(1).replace(/\.0$/, "")}s`;
+  }
+  return `${Math.round(durationSeconds)}s`;
+}
+function resolveTotalTokens(usage) {
+  if (usage?.totalTokens !== void 0) {
+    return usage.totalTokens;
+  }
+  if (usage?.inputTokens !== void 0 && usage.outputTokens !== void 0) {
+    return usage.inputTokens + usage.outputTokens;
+  }
+  return void 0;
+}
+function buildSlackReplyFooter(args) {
+  const items = [];
+  const conversationId = args.conversationId?.trim();
+  if (conversationId) {
+    items.push({
+      label: "ID",
+      value: conversationId
+    });
+  }
+  const totalTokens = resolveTotalTokens(args.usage);
+  if (totalTokens !== void 0) {
+    items.push({
+      label: "Tokens",
+      value: formatSlackTokenCount(totalTokens)
+    });
+  }
+  if (typeof args.durationMs === "number" && Number.isFinite(args.durationMs)) {
+    const durationMs = Math.max(0, Math.floor(args.durationMs));
+    items.push({
+      label: "Time",
+      value: formatSlackDuration(durationMs)
+    });
+  }
+  const traceId = args.traceId?.trim();
+  if (traceId) {
+    items.push({
+      label: "Trace",
+      value: traceId
+    });
+  }
+  return items.length > 0 ? { items } : void 0;
+}
+function buildSlackReplyBlocks(text, footer) {
+  if (!text.trim() || !footer?.items.length) {
+    return void 0;
+  }
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text
+      }
+    },
+    {
+      type: "context",
+      elements: footer.items.map((item) => ({
+        type: "mrkdwn",
+        text: `*${escapeSlackMrkdwn(item.label)}:* ${escapeSlackMrkdwn(item.value)}`
+      }))
+    }
+  ];
+}
+
 // src/chat/slack/reply.ts
 import { Buffer as Buffer2 } from "buffer";
 function isInterruptedVisibleReply(reply) {
@@ -10892,14 +11011,25 @@ async function normalizeFileUploads(files) {
     })
   );
 }
-async function uploadReplyFilesBestEffort(args) {
+function findLastTextPostIndex(posts) {
+  for (let index = posts.length - 1; index >= 0; index -= 1) {
+    if (posts[index]?.text.trim().length) {
+      return index;
+    }
+  }
+  return -1;
+}
+async function uploadReplyFiles(args) {
   try {
     await uploadFilesToThread({
       channelId: args.channelId,
       threadTs: args.threadTs,
       files: await normalizeFileUploads(args.files)
     });
-  } catch {
+  } catch (error) {
+    if (args.failureMode === "strict") {
+      throw error;
+    }
   }
 }
 function planSlackReplyPosts(args) {
@@ -10937,19 +11067,44 @@ function planSlackReplyPosts(args) {
   return posts;
 }
 async function postSlackApiReplyPosts(args) {
-  for (const post of args.posts) {
-    if (post.text.trim().length > 0) {
-      await args.postMessage(args.channelId, args.threadTs, post.text);
-    }
-    if (!post.files?.length) {
-      continue;
+  const lastTextPostIndex = findLastTextPostIndex(args.posts);
+  let lastPostedMessageTs;
+  for (const [index, post] of args.posts.entries()) {
+    const hasVisibleDelivery = post.text.trim().length > 0 || post.files?.length;
+    if (hasVisibleDelivery) {
+      await args.beforePost?.();
+    }
+    let messageTs;
+    try {
+      if (post.text.trim().length > 0) {
+        const response = await postSlackMessage({
+          channelId: args.channelId,
+          threadTs: args.threadTs,
+          text: post.text,
+          ...index === lastTextPostIndex && args.footer ? { blocks: buildSlackReplyBlocks(post.text, args.footer) } : {}
+        });
+        messageTs = response.ts;
+        lastPostedMessageTs = response.ts;
+      }
+      if (!post.files?.length) {
+        continue;
+      }
+      await uploadReplyFiles({
+        channelId: args.channelId,
+        failureMode: args.fileUploadFailureMode ?? "best_effort",
+        threadTs: args.threadTs,
+        files: post.files
+      });
+    } catch (error) {
+      await args.onPostError?.({
+        error,
+        messageTs,
+        stage: post.stage
+      });
+      throw error;
     }
-    await uploadReplyFilesBestEffort({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      files: post.files
-    });
   }
+  return lastPostedMessageTs;
 }
 
 // src/chat/slack/resume.ts
@@ -10964,16 +11119,13 @@ function resolveReplyTimeoutMs(explicitTimeoutMs) {
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
-async function postSlackMessage2(channelId, threadTs, text) {
-  await postSlackMessage({
-    channelId,
-    threadTs,
-    text
-  });
-}
 async function postSlackMessageBestEffort(channelId, threadTs, text) {
   try {
-    await postSlackMessage2(channelId, threadTs, text);
+    await postSlackMessage({
+      channelId,
+      threadTs,
+      text
+    });
   } catch {
   }
 }
@@ -11097,11 +11249,18 @@ async function resumeSlackTurn(args) {
       )
     ]) : await replyPromise;
     await status.stop();
+    const footer = buildSlackReplyFooter({
+      conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
+      durationMs: reply.diagnostics.durationMs,
+      traceId: getActiveTraceId(),
+      usage: reply.diagnostics.usage
+    });
     await postSlackApiReplyPosts({
       channelId: args.channelId,
       threadTs: args.threadTs,
       posts: planSlackReplyPosts({ reply }),
-      postMessage: postSlackMessage2
+      fileUploadFailureMode: "best_effort",
+      footer
     });
     await args.onSuccess?.(reply);
   } catch (error) {
@@ -11903,11 +12062,11 @@ async function GET5(request, provider, waitUntil) {
   } else if (stored.channelId && stored.threadTs) {
     const { channelId, threadTs } = stored;
     waitUntil(
-      () => postSlackMessage2(
+      () => postSlackMessage({
         channelId,
         threadTs,
-        `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
-      )
+        text: `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
+      })
     );
   }
   const statusMessage = stored.pendingMessage ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
@@ -12553,11 +12712,20 @@ function getAssistantThreadContext(message) {
   const raw = message.raw;
   const rawRecord = raw && typeof raw === "object" ? raw : void 0;
   const channelId = toOptionalString(rawRecord?.channel);
-  const threadTs = toOptionalString(rawRecord?.thread_ts);
-  if (!channelId || !threadTs) {
+  if (channelId) {
+    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
+    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
+    if (threadTs) {
+      return { channelId, threadTs };
+    }
+  }
+  const parsedThreadId = parseSlackThreadId(
+    toOptionalString(message.threadId)
+  );
+  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
     return void 0;
   }
-  return { channelId, threadTs };
+  return parsedThreadId;
 }
 function getMessageTs(message) {
   const directTs = toOptionalString(
@@ -13948,13 +14116,63 @@ function createReplyToThread(deps) {
             "slackMessageAddReaction"
           );
           const plannedPosts = planSlackReplyPosts({ reply });
+          const replyFooter = buildSlackReplyFooter({
+            conversationId,
+            durationMs: reply.diagnostics.durationMs,
+            traceId: getActiveTraceId(),
+            usage: reply.diagnostics.usage
+          });
+          const shouldUseSlackFooter = Boolean(replyFooter) && Boolean(channelId && threadTs) && thread.adapter?.name === "slack";
           if (plannedPosts.length > 0) {
             let sent;
-            for (const post of plannedPosts) {
-              sent = await postThreadReply(
-                buildSlackOutputMessage(post.text, post.files),
-                post.stage
-              );
+            if (shouldUseSlackFooter) {
+              const slackChannelId = channelId;
+              const slackThreadTs = threadTs;
+              if (!slackChannelId || !slackThreadTs) {
+                throw new Error(
+                  "Slack footer delivery requires a concrete channel and thread timestamp"
+                );
+              }
+              const sentMessageTs = await postSlackApiReplyPosts({
+                beforePost: beforeFirstResponsePost,
+                channelId: slackChannelId,
+                threadTs: slackThreadTs,
+                posts: plannedPosts,
+                fileUploadFailureMode: "strict",
+                footer: replyFooter,
+                onPostError: ({ error, messageTs: messageTs2, stage }) => {
+                  logException(
+                    error,
+                    "slack_thread_post_failed",
+                    turnTraceContext,
+                    {
+                      "app.slack.reply_stage": stage,
+                      ...messageTs2 ? { "messaging.message.id": messageTs2 } : {},
+                      ...getSlackErrorObservabilityAttributes(error)
+                    },
+                    "Failed to post Slack thread reply"
+                  );
+                }
+              });
+              if (sentMessageTs) {
+                sent = {
+                  id: sentMessageTs,
+                  text: reply.text,
+                  delete: async () => {
+                    await deleteSlackMessage({
+                      channelId: slackChannelId,
+                      timestamp: sentMessageTs
+                    });
+                  }
+                };
+              }
+            } else {
+              for (const post of plannedPosts) {
+                sent = await postThreadReply(
+                  buildSlackOutputMessage(post.text, post.files),
+                  post.stage
+                );
+              }
             }
             const firstPlannedMessageHasFiles = (plannedPosts[0]?.files?.length ?? 0) > 0;
             if (sent && reactionPerformed && plannedPosts.length === 1 && !firstPlannedMessageHasFiles && isRedundantReactionAckText(reply.text)) {

package/dist/{chunk-J7JEFMVD.js → chunk-I3WA75AD.js}

@@ -1236,7 +1236,7 @@ function collectUsageRoots(source) {
   }
   return roots;
 }
-function extractGenAiUsageAttributes(...sources) {
+function extractGenAiUsageSummary(...sources) {
   const roots = sources.flatMap((source) => collectUsageRoots(source));
   if (roots.length === 0) {
     return {};
@@ -1261,6 +1261,21 @@ function extractGenAiUsageAttributes(...sources) {
       "completionTokenCount"
     ])
   ).find((value) => value !== void 0) ?? void 0;
+  const totalTokens = roots.map(
+    (root) => readTokenCount(root, [
+      "total_tokens",
+      "totalTokens",
+      "totalTokenCount"
+    ])
+  ).find((value) => value !== void 0) ?? void 0;
+  return {
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  };
+}
+function extractGenAiUsageAttributes(...sources) {
+  const { inputTokens, outputTokens } = extractGenAiUsageSummary(...sources);
   return {
     ...inputTokens !== void 0 ? { "gen_ai.usage.input_tokens": inputTokens } : {},
     ...outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": outputTokens } : {}
@@ -2789,6 +2804,7 @@ export {
   getActiveTraceId,
   resolveErrorReference,
   serializeGenAiAttribute,
+  extractGenAiUsageSummary,
   extractGenAiUsageAttributes,
   resolveAuthTokenPlaceholder,
   parsePluginManifest,

package/dist/{chunk-DGN3WLA4.js → chunk-O5N42P7K.js}

@@ -5,7 +5,7 @@ import {
   getPluginSkillRoots,
   logInfo,
   logWarn
-} from "./chunk-J7JEFMVD.js";
+} from "./chunk-I3WA75AD.js";
 import {
   skillRoots
 } from "./chunk-XPXD3FCE.js";

package/dist/{chunk-B5O2EJUV.js → chunk-RMVXZMXQ.js}

@@ -2,7 +2,7 @@ import {
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall,
   withSpan
-} from "./chunk-J7JEFMVD.js";
+} from "./chunk-I3WA75AD.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/cli/check.js

@@ -1,9 +1,9 @@
 import {
   parseSkillFile
-} from "../chunk-DGN3WLA4.js";
+} from "../chunk-O5N42P7K.js";
 import {
   parsePluginManifest
-} from "../chunk-J7JEFMVD.js";
+} from "../chunk-I3WA75AD.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-XPXD3FCE.js";
 import "../chunk-2KG3PWR4.js";

package/dist/cli/snapshot-warmup.js

@@ -1,12 +1,12 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-B5O2EJUV.js";
+} from "../chunk-RMVXZMXQ.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-J7JEFMVD.js";
+} from "../chunk-I3WA75AD.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-XPXD3FCE.js";
 import "../chunk-2KG3PWR4.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "private": false,
   "publishConfig": {
     "access": "public"