@sentry/junior 0.147.0 → 0.148.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-PVNG6UMU.js";
+} from "./chunk-D6YX4NNN.js";
 import {
   bindSpawnAgent
-} from "./chunk-745QJ3ZA.js";
+} from "./chunk-7OEIXFC3.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-YEO3VX72.js";
+} from "./chunk-OJCP3C3J.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -25,21 +25,36 @@ import {
   getSlackErrorObservabilityAttributes,
   getThreadId,
   getThreadTs,
-  getTurnRequestDeadline,
   isRetryableSlackPostError,
   isSlackTitlePermissionError,
   publishAppHomeView,
   receiveLocalOAuthCredential,
   resumeSlackTurn,
-  runWithTurnRequestDeadline,
   sendSlackReply,
   shouldKeepProcessingReactionForToolInvocation,
   splitSlackReplyText,
   startSlackProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-AYU72WO7.js";
+} from "./chunk-ULAU5ZGU.js";
 import "./chunk-FA6POGLH.js";
+import {
+  getTurnRequestDeadline,
+  runWithTurnRequestDeadline
+} from "./chunk-DUY5CDAM.js";
+import {
+  completeAuthPauseTurn,
+  persistAuthPauseTurnState
+} from "./chunk-LNVEIJ2L.js";
+import {
+  GET,
+  conversationVisibilityFromSlackChannelType,
+  createApiTurnWorker,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  routeApiTurnWork
+} from "./chunk-ZPL2RR7F.js";
+import "./chunk-4CODA7P5.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -50,12 +65,11 @@ import {
   isInvalidConversationRecordError,
   listActiveConversationIds,
   removeActiveConversation
-} from "./chunk-CWP5RHVX.js";
+} from "./chunk-HLPLT3NY.js";
 import {
   buildConversationContext,
   buildDeliveredTurnStatePatch,
   claimDispatchMailboxAppend,
-  completeAuthPauseTurn,
   confirmDispatchMailboxAppend,
   createConversationMemoryService,
   createOrGetDispatch,
@@ -83,15 +97,15 @@ import {
   markDispatchFailed,
   markDispatchRunning,
   normalizeConversationText,
-  persistAuthPauseTurnState,
   processPluginTask,
   recordDeliveredAssistantMessage,
+  recordTaskExecution,
   requireTurnFailureEventId,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-6H5SZR24.js";
+} from "./chunk-RRJV5UR5.js";
 import {
   ConversationTurnLifecycleService,
   coerceThreadConversationState,
@@ -101,17 +115,7 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-AZ7EAOBE.js";
-import {
-  GET,
-  conversationVisibilityFromSlackChannelType,
-  resolveSlackChannelTypeFromMessage,
-  resolveSlackConversationContext
-} from "./chunk-34GS7B6L.js";
-import "./chunk-4CODA7P5.js";
-import {
-  recordTaskExecution
-} from "./chunk-AVOCH2Z5.js";
+} from "./chunk-IL4EDBMV.js";
 import "./chunk-UTL3MHPC.js";
 import {
   getVercelConversationWorkQueue,
@@ -130,7 +134,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-YNTTROJT.js";
+} from "./chunk-QOWHHM3F.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -163,29 +167,47 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-7A4M7PCV.js";
+} from "./chunk-VMNRXKAH.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-X5UY34KT.js";
+} from "./chunk-EINWQFXI.js";
 import "./chunk-DIB4GX3G.js";
 import {
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-Q4R73I43.js";
+} from "./chunk-XJ42NBP5.js";
 import {
   RetryableDeliveryError
-} from "./chunk-R776HKPK.js";
+} from "./chunk-GDFF3BQG.js";
 import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-7UQIVT6G.js";
+} from "./chunk-WCN4YSH7.js";
+import "./chunk-HUO3UTAQ.js";
+import {
+  getExperimentalFeatures,
+  setExperimentalFeatures
+} from "./chunk-5IDFPCON.js";
+import {
+  getSandboxResourceConfig,
+  setSandboxResourceConfig
+} from "./chunk-VY6W3T43.js";
+import {
+  createSchedulerSqlStore,
+  findMatchingEventTasks,
+  logScheduledTaskRunSkipped,
+  scheduledTaskRunAttributes
+} from "./chunk-GXYDVZKM.js";
+import {
+  parseSlackThreadId
+} from "./chunk-WOONT5ZP.js";
 import {
   estimateTextTokens
-} from "./chunk-K4SZAP3K.js";
+} from "./chunk-4EA2SFK2.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -223,28 +245,8 @@ import {
   startActiveTurn,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-AIOK6LAG.js";
+} from "./chunk-VCYSOXON.js";
 import "./chunk-3Y47VMHV.js";
-import "./chunk-HUO3UTAQ.js";
-import {
-  getExperimentalFeatures,
-  setExperimentalFeatures
-} from "./chunk-5IDFPCON.js";
-import {
-  getSandboxResourceConfig,
-  setSandboxResourceConfig
-} from "./chunk-AVZDSUFB.js";
-import {
-  createSchedulerSqlStore,
-  findMatchingEventTasks,
-  logScheduledTaskRunSkipped,
-  scheduledTaskRunAttributes
-} from "./chunk-EFLJ2WJH.js";
-import {
-  parseSlackThreadId
-} from "./chunk-CSZINQJ2.js";
-import "./chunk-Z4YU7Z4L.js";
-import "./chunk-HLXXQI5Q.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -263,7 +265,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-YHDERDRO.js";
+} from "./chunk-ZCHIC2GM.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -273,7 +275,7 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-SGZO7UWH.js";
+} from "./chunk-V2FXMOEA.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -286,19 +288,19 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-YSB2N563.js";
+} from "./chunk-VRHTNBA6.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-DU74WPIC.js";
+} from "./chunk-D3WPMGEX.js";
 import "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-ORO3PWKQ.js";
+} from "./chunk-2B3PT3V2.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -316,16 +318,16 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-7NVJVJID.js";
+} from "./chunk-4GXJUYJV.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-RXBVB2JM.js";
-import "./chunk-YBVXBNSV.js";
+import "./chunk-LE5H7LMT.js";
+import "./chunk-4AQZYNHM.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JUUKWRBE.js";
-import "./chunk-GGB4WL5A.js";
+} from "./chunk-HWQGBIH7.js";
+import "./chunk-POSZWRGL.js";
 import {
   credentialContextForActor
 } from "./chunk-RUIXF3YQ.js";
@@ -359,7 +361,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-4LJO56OJ.js";
+} from "./chunk-EAI67NTM.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -367,10 +369,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-DLDRQHG5.js";
+} from "./chunk-LAZGHEYU.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-IIOOO4FQ.js";
+} from "./chunk-55F4QU2V.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -474,6 +476,7 @@ function buildAgentDispatchInboundMessage(dispatch2, nowMs = Date.now()) {
       }
     },
     receivedAtMs: nowMs,
+    publishExternally: true,
     source: "plugin"
   };
 }
@@ -1214,13 +1217,23 @@ var SCHEDULE_FREQUENCY_COPY = {
 function singleLineMetadataValue(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
 }
+function buildDispatchInput(task) {
+  const creator = sanitizeScheduledTaskPrincipal(task.createdBy);
+  return [
+    "You are executing a scheduled task.",
+    "",
+    "Task:",
+    `- creator: <@${creator.slackUserId}>`,
+    "",
+    "Stored user instruction:",
+    task.task.text
+  ].join("\n");
+}
 function buildDispatchMetadata(args) {
-  const creator = sanitizeScheduledTaskPrincipal(args.task.createdBy);
   if (!args.task.task.text?.trim()) {
     throw new Error("Scheduled task text is required");
   }
   return {
-    creatorSlackUserId: creator.slackUserId,
     runId: args.run.id,
     schedule: singleLineMetadataValue(args.task.schedule.description),
     scheduleKind: args.task.schedule.kind,
@@ -1507,7 +1520,7 @@ async function runScheduledTaskHeartbeat(args) {
           } : {},
           destination: task.destination,
           destinationVisibility: task.conversationAccess.visibility,
-          input: task.task.text,
+          input: buildDispatchInput(task),
           metadata,
           replyAttribution: replyAttribution(task),
           source: dispatchSource(task)
@@ -2976,6 +2989,7 @@ function createSlackResourceEventInboundMessage(input) {
     delivery: "defer",
     source: "resource_event",
     receivedAtMs: Date.now(),
+    publishExternally: true,
     input: {
       text: input.text,
       authorId: RESOURCE_EVENT_SLACK_AUTHOR_ID,
@@ -3180,7 +3194,9 @@ function createSlackConversationWorker(options) {
         };
         const drainSteeringMessages = async (accept) => {
           await context.attempt.drain(async (pendingRecords) => {
-            const candidates = pendingRecords.map((record) => ({
+            const candidates = pendingRecords.filter(
+              (record) => record.publishExternally === context.publishExternally
+            ).map((record) => ({
               inboundMessageId: record.inboundMessageId,
               message: restoreMessage({ adapter, record })
             })).filter(
@@ -3194,6 +3210,7 @@ function createSlackConversationWorker(options) {
             await options.runtime.handleNewMention(thread, latestMessage, {
               conversationId: context.conversationId,
               destination,
+              publishExternally: context.publishExternally,
               messageContext,
               drainSteeringMessages,
               ack,
@@ -3207,6 +3224,7 @@ function createSlackConversationWorker(options) {
               {
                 conversationId: context.conversationId,
                 destination,
+                publishExternally: context.publishExternally,
                 messageContext,
                 drainSteeringMessages,
                 ack,
@@ -3258,6 +3276,7 @@ function buildSlackInboundMessage(args) {
     source: "slack",
     createdAtMs: args.message.metadata.dateSent.getTime(),
     receivedAtMs: args.receivedAtMs,
+    publishExternally: true,
     input: {
       text: args.message.text || " ",
       authorId,
@@ -4800,6 +4819,9 @@ function buildLogContext(deps, args) {
 function actorUserName(message) {
   return getMessageActorIdentity(message)?.userName;
 }
+function shouldPublishExternally(publishExternally) {
+  return publishExternally !== false;
+}
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
   const maybeHandleThreadOptOutDecision = async (args) => {
@@ -5113,6 +5135,7 @@ function createSlackTurnRuntime(deps) {
             conversationId: hooks.conversationId,
             destination: hooks.destination,
             queuedMessages,
+            publishExternally: shouldPublishExternally(hooks.publishExternally),
             ack,
             onToolInvocation: toolInvocationHook,
             onTurnCompleted,
@@ -5170,11 +5193,13 @@ function createSlackTurnRuntime(deps) {
           lifecycleError = error2;
         }
         await hooks.beforeFirstResponsePost?.();
-        await postFallbackErrorReplyWithLogging({
-          thread,
-          eventId,
-          postFailureEventName: "mention.handler.failure_reply_post.failed"
-        });
+        if (shouldPublishExternally(hooks.publishExternally)) {
+          await postFallbackErrorReplyWithLogging({
+            thread,
+            eventId,
+            postFailureEventName: "mention.handler.failure_reply_post.failed"
+          });
+        }
         if (lifecycleError) throw lifecycleError;
       } finally {
         if (completed) {
@@ -5374,6 +5399,7 @@ function createSlackTurnRuntime(deps) {
             conversationId: hooks.conversationId,
             destination: hooks.destination,
             preparedState,
+            publishExternally: shouldPublishExternally(hooks.publishExternally),
             beforeFirstResponsePost: hooks.beforeFirstResponsePost,
             queuedMessages,
             ack,
@@ -5436,11 +5462,13 @@ function createSlackTurnRuntime(deps) {
           lifecycleError = error2;
         }
         await hooks.beforeFirstResponsePost?.();
-        await postFallbackErrorReplyWithLogging({
-          thread,
-          eventId,
-          postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
-        });
+        if (shouldPublishExternally(hooks.publishExternally)) {
+          await postFallbackErrorReplyWithLogging({
+            thread,
+            eventId,
+            postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
+          });
+        }
         if (lifecycleError) throw lifecycleError;
       } finally {
         if (completed) {
@@ -6240,6 +6268,9 @@ async function loadPiMessagesForTurn(args) {
   }
   return {};
 }
+function shouldPublishExternally2(publishExternally) {
+  return publishExternally !== false;
+}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options) {
     if (message.author.isMe) {
@@ -6376,6 +6407,9 @@ function createReplyToThread(deps) {
           );
           try {
             await beforeFirstResponsePost();
+            if (!shouldPublishExternally2(options.publishExternally)) {
+              return;
+            }
             if (channelId && threadTs) {
               await sendSlackReply({
                 channelId,
@@ -6570,7 +6604,9 @@ function createReplyToThread(deps) {
         });
         if (configReply) {
           await beforeFirstResponsePost();
-          await thread.post(buildSlackOutputMessage(configReply.text));
+          if (shouldPublishExternally2(options.publishExternally)) {
+            await thread.post(buildSlackOutputMessage(configReply.text));
+          }
           markConversationMessage(
             preparedState.conversation,
             preparedState.userMessageId,
@@ -6737,19 +6773,21 @@ function createReplyToThread(deps) {
           let slackMessageTs2 = [];
           await beforeFirstResponsePost();
           try {
-            if (channelId && thread.adapter.name === "slack") {
-              slackMessageTs2 = await sendSlackReply({
-                channelId,
-                conversationId,
-                replyAttribution: options.execution?.dispatch?.replyAttribution,
-                text,
-                ...threadTs ? { threadTs } : {}
-              });
-            } else {
-              for (const part of splitSlackReplyText(text)) {
-                const postedMessageTs = (await thread.post(buildSlackOutputMessage(part))).id;
-                if (postedMessageTs) {
-                  slackMessageTs2.push(postedMessageTs);
+            if (shouldPublishExternally2(options.publishExternally)) {
+              if (channelId && thread.adapter.name === "slack") {
+                slackMessageTs2 = await sendSlackReply({
+                  channelId,
+                  conversationId,
+                  replyAttribution: options.execution?.dispatch?.replyAttribution,
+                  text,
+                  ...threadTs ? { threadTs } : {}
+                });
+              } else {
+                for (const part of splitSlackReplyText(text)) {
+                  const postedMessageTs = (await thread.post(buildSlackOutputMessage(part))).id;
+                  if (postedMessageTs) {
+                    slackMessageTs2.push(postedMessageTs);
+                  }
                 }
               }
             }
@@ -6980,6 +7018,7 @@ function createReplyToThread(deps) {
               slackConversation,
               source,
               destination,
+              publishExternally: shouldPublishExternally2(options.publishExternally),
               ...destinationVisibility ? { destinationVisibility } : {},
               surface: options.execution?.surface ?? "slack",
               dispatch: options.execution?.dispatch,
@@ -7465,21 +7504,26 @@ function getBackfillText(entry) {
   const text = normalizeConversationText(parseContent(entry).text);
   return text || void 0;
 }
-async function seedConversationBackfill(thread, conversation, currentTurn) {
+async function seedConversationBackfill(thread, conversation, currentTurn, resolveMessageActors) {
   if (conversation.messages.length > 0 || conversation.compactions.length > 0) {
     return "recent_messages";
   }
   const seeded = [];
   let source = "recent_messages";
+  let fetchedNewestFirst;
   try {
-    const fetchedNewestFirst = [];
+    const fetched = [];
     for await (const entry of thread.messages) {
-      fetchedNewestFirst.push(entry);
-      if (fetchedNewestFirst.length >= BACKFILL_MESSAGE_LIMIT) {
+      fetched.push(entry);
+      if (fetched.length >= BACKFILL_MESSAGE_LIMIT) {
         break;
       }
     }
-    fetchedNewestFirst.reverse();
+    fetchedNewestFirst = fetched.reverse();
+  } catch {
+  }
+  if (fetchedNewestFirst) {
+    await resolveMessageActors(fetchedNewestFirst);
     for (const entry of fetchedNewestFirst) {
       const text = getBackfillText(entry);
       if (text) {
@@ -7489,7 +7533,6 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
     if (seeded.length > 0) {
       source = "thread_fetch";
     }
-  } catch {
   }
   if (seeded.length === 0) {
     try {
@@ -7497,6 +7540,7 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
     } catch {
     }
     const fromRecent = thread.recentMessages.slice(-BACKFILL_MESSAGE_LIMIT);
+    await resolveMessageActors(fromRecent);
     for (const entry of fromRecent) {
       const text = getBackfillText(entry);
       if (text) {
@@ -7528,10 +7572,15 @@ function createPrepareTurnState(deps) {
     await hydrateConversationMessages({ conversation, conversationId });
     const locationConfiguration = args.locationConfiguration ?? getLocationConfigurationService(args.destination);
     const configuration = await locationConfiguration.resolveValues();
-    const backfillSource = args.skipBackfill ? void 0 : await seedConversationBackfill(args.thread, conversation, {
-      messageId: args.message.id,
-      messageCreatedAtMs: args.message.metadata.dateSent.getTime()
-    });
+    const backfillSource = args.skipBackfill ? void 0 : await seedConversationBackfill(
+      args.thread,
+      conversation,
+      {
+        messageId: args.message.id,
+        messageCreatedAtMs: args.message.metadata.dateSent.getTime()
+      },
+      (messages) => deps.resolveBackfillMessageActors(messages, args.destination)
+    );
     for (const queued of args.queuedMessages ?? []) {
       const queuedMessage = toConversationMessage({
         entry: queued.message,
@@ -7565,7 +7614,10 @@ function createPrepareTurnState(deps) {
         threadTs: getThreadTs(args.context.threadId)
       });
       if (conversationId) {
-        await persistConversationVisionCache(conversationId, conversation.vision);
+        await persistConversationVisionCache(
+          conversationId,
+          conversation.vision
+        );
       }
     }
     await persistConversationMessages({ conversation, conversationId });
@@ -7650,6 +7702,7 @@ function createSlackDispatchTurnRunner(options) {
       ack: hooks.ack,
       conversationId,
       destination: dispatch2.destination,
+      publishExternally: true,
       execution: {
         disabledFeatures: ["interactive-auth"],
         locationConfiguration: options.getLocationConfiguration(
@@ -7706,7 +7759,24 @@ function createSlackRuntime(options) {
   const services = createJuniorRuntimeServices(options.services);
   const prepareTurnState = createPrepareTurnState({
     compactConversationIfNeeded: services.conversationMemory.compactConversationIfNeeded,
-    hydrateConversationVisionContext: services.visionContext.hydrateConversationVisionContext
+    hydrateConversationVisionContext: services.visionContext.hydrateConversationVisionContext,
+    resolveBackfillMessageActors: async (messages, destination) => {
+      if (destination.platform !== "slack") {
+        throw new Error("Slack turn backfill requires a Slack destination");
+      }
+      await Promise.all(
+        messages.filter((message) => {
+          const actor = getMessageActorIdentity(message);
+          return !message.author.isMe && Boolean(actor?.userId) && !actor?.fullName && !actor?.userName;
+        }).map(
+          (message) => ensureSlackMessageActorIdentity(
+            message,
+            destination.teamId,
+            services.replyExecutor.lookupSlackUser
+          )
+        )
+      );
+    }
   });
   const replyToThread = createReplyToThread({
     getSlackAdapter: options.getSlackAdapter,
@@ -8145,6 +8215,9 @@ async function runPausedTurnInContext(payload, options, runOptions) {
               credentialContext,
               actor,
               destination: routingDestination,
+              // Slack resume publishes unless the checkpoint opted out.
+              // Missing means legacy/in-flight Slack turns still post.
+              publishExternally: activeTurn.publishExternally !== false,
               source,
               toolChannelId: destination.channelId
             },
@@ -8419,11 +8492,16 @@ function createConversationWork(options) {
   return {
     conversationStore: options.conversationStore,
     queue: options.queue,
-    run: routeAgentInvocationWork({
-      invocationWorker: createAgentInvocationWorker({
+    run: routeApiTurnWork({
+      apiTurnWorker: createApiTurnWorker({
         agentRunner: options.agentRunner
       }),
-      fallbackWorker: providerWorker
+      fallbackWorker: routeAgentInvocationWork({
+        invocationWorker: createAgentInvocationWorker({
+          agentRunner: options.agentRunner
+        }),
+        fallbackWorker: providerWorker
+      })
     }),
     runtime,
     state: options.state

package/dist/{catalog-runtime-M6ZTPYRV.js → catalog-runtime-WADOZVTB.js}

@@ -1,16 +1,16 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-JUUKWRBE.js";
-import "./chunk-GGB4WL5A.js";
+} from "./chunk-HWQGBIH7.js";
+import "./chunk-POSZWRGL.js";
 import "./chunk-RUIXF3YQ.js";
 import "./chunk-HZF5P5UN.js";
 import "./chunk-F3B2YJ76.js";
-import "./chunk-4LJO56OJ.js";
+import "./chunk-EAI67NTM.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-DLDRQHG5.js";
-import "./chunk-IIOOO4FQ.js";
+import "./chunk-LAZGHEYU.js";
+import "./chunk-55F4QU2V.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/actor.d.ts

@@ -26,11 +26,14 @@ export interface SlackActor extends BaseActor {
 export interface LocalActor extends BaseActor {
     platform: "local";
 }
+export interface WebActor extends BaseActor {
+    platform: "web";
+}
 export interface SystemActor {
     platform: "system";
     name: string;
 }
-export type UserActor = SlackActor | LocalActor;
+export type UserActor = SlackActor | LocalActor | WebActor;
 export type Actor = UserActor | SystemActor;
 export interface SlackActorProfile {
     email?: string;

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

@@ -96,6 +96,8 @@ export interface AgentRunRouting {
      */
     slackActionToken?: SlackActionToken;
     destination: Destination;
+    /** When true, also publish assistant output to the conversation destination. */
+    publishExternally?: boolean;
     /** Confirmed visibility of the destination where this run is delivered. */
     destinationVisibility?: ConversationPrivacy;
     surface?: AgentTurnSurface;