@sentry/junior 0.185.0 → 0.187.0

package/dist/chat/task-execution/slack-resource-event.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Slack edge helpers for resource-event mailbox wakes.
+ *
+ * Resource-event ingest stores plain conversation mailbox input. When the
+ * conversation destination is Slack, this module builds the Message and Thread
+ * the Slack runtime needs for one turn. It does not rewrite mailbox rows.
+ *
+ * TODO(slack-runtime): Drop this module once Slack turns can start from
+ * conversation destination + session source (channel, team, threadTs, text,
+ * event metadata) without a synthetic chat Message/Thread. Resource wakes and
+ * paused resume should share that entry; handleSubscribedMessage stays for
+ * real webhook traffic only.
+ */
+import { Message, ThreadImpl, type StateAdapter } from "chat";
+import type { SlackAdapter } from "@chat-adapter/slack";
+import type { Destination, SlackDestination } from "@sentry/junior-plugin-api";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { InboundMessage } from "@/chat/task-execution/store";
+/** Load Slack destination and threadTs for a resource-event wake. */
+export declare function resolveSlackResourceEventThread(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    destination?: Destination;
+}): Promise<{
+    destination: SlackDestination;
+    threadTs: string;
+}>;
+/** Whether a mailbox row is a plain resource-event wake (no Slack envelope). */
+export declare function isPlainResourceEventRecord(record: InboundMessage): boolean;
+/**
+ * Build a Slack Message for one plain resource-event mailbox row.
+ *
+ * Used only at the Slack worker edge. The mailbox row stays plain.
+ */
+export declare function buildResourceEventSlackMessage(args: {
+    channelId: string;
+    record: InboundMessage;
+    threadTs: string;
+}): Message;
+/** Build a ThreadImpl for a resource-event Slack turn. */
+export declare function buildResourceEventSlackThread(args: {
+    adapter: SlackAdapter;
+    message: Message;
+    state: StateAdapter;
+    threadTs: string;
+    channelId: string;
+}): ThreadImpl;

package/dist/chat/task-execution/slack-work.d.ts

@@ -251,25 +251,6 @@ interface SlackInboxTurnRuntime {
     handleNewMention(thread: ThreadImpl, message: Message, hooks: SlackInboxTurnOptions): Promise<void>;
     handleSubscribedMessage(thread: ThreadImpl, message: Message, hooks: SlackInboxTurnOptions): Promise<void>;
 }
-interface SlackResourceEventInboundInput {
-    event: {
-        eventKey: string;
-        eventType: string;
-        occurredAtMs: number;
-        namespace: string;
-        identifier: string;
-    };
-    subscription: {
-        conversationId: string;
-        destination: {
-            channelId: string;
-            platform: "slack";
-            teamId: string;
-        };
-        id: string;
-    };
-    text: string;
-}
 export interface CreateSlackConversationWorkerOptions {
     crossActorMidRunMode?: CrossActorMidRunMode;
     getSlackAdapter: () => SlackAdapter;
@@ -281,8 +262,6 @@ export interface CreateSlackConversationWorkerOptions {
     runtime: SlackInboxTurnRuntime;
     state?: StateAdapter;
 }
-/** Create a Slack mailbox record for a subscribed resource-event notification. */
-export declare function createSlackResourceEventInboundMessage(input: SlackResourceEventInboundInput): InboundMessage;
 /** Build the worker run function for queued Slack conversation work. */
 export declare function createSlackConversationWorker(options: CreateSlackConversationWorkerOptions): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Serialize a Slack message into the generic durable conversation mailbox. */

package/dist/chat/task-input.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Render agent input for a task run.
+ *
+ * Section order and required prose live in `chat/README.md` under Task agent
+ * input. Empty optional fields are omitted.
+ */
+export declare function renderTaskInput(args: {
+    /** Stored task instruction, or subscription intent. */
+    instructions: string;
+    /** Human label for the matched resource, when present. */
+    about?: string;
+    /** Plugin guidance scoped under the instructions. */
+    guidance?: string;
+    /** Trusted one-line summary, when available. */
+    trustedSummary?: string;
+    /** Structured verified fields, when available. */
+    verifiedDetails?: Record<string, unknown>;
+    /** Untrusted provider text; never treated as instructions. */
+    externalText?: string;
+    externalTextMaxLength?: number;
+    trustedSummaryMaxLength?: number;
+}): string;

package/dist/chat/tools/event-tasks.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
+import { type ResourceEventCatalog } from "@/chat/resource-events/catalog";
 import type { ToolRegistry } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 /** Build event task tools for an interactive Slack actor. */

package/dist/chat/tools/resource-events.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
+import { type ResourceEventCatalog } from "@/chat/resource-events/catalog";
 import type { ToolRegistry } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 /** Build the complete resource-watch tool set for this runtime context. */

package/dist/{chunk-Y5G23T2D.js → chunk-27T5HZHO.js}

@@ -1,18 +1,18 @@
 import {
   persistConversationMessages
-} from "./chunk-WLKWN4CD.js";
+} from "./chunk-D5BWM37G.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
 import {
   getDb
-} from "./chunk-ABAX75GG.js";
+} from "./chunk-WKIS4VRK.js";
 import {
   juniorLocationConfigurations
-} from "./chunk-LVK4WJKM.js";
+} from "./chunk-HXR3FHTE.js";
 import {
   getStateAdapter
-} from "./chunk-PNYJOEVV.js";
+} from "./chunk-U6ZQHRIP.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -20,7 +20,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-OMQ2J6F6.js";
+} from "./chunk-6YCIYOVA.js";
 
 // src/chat/state/conversation.ts
 function defaultConversationState() {
@@ -372,7 +372,10 @@ function createSqlLocationConfigurationStorage(db, destination) {
   };
 }
 function createDurableLocationConfigurationService(args) {
-  const storage = createSqlLocationConfigurationStorage(args.db, args.destination);
+  const storage = createSqlLocationConfigurationStorage(
+    args.db,
+    args.destination
+  );
   let cutover;
   const ensureCutover = () => cutover ??= (async () => {
     if ((await storage.list()).length > 0) {
@@ -504,6 +507,85 @@ function getLocationConfigurationService(destination) {
   });
 }
 
+// src/chat/services/turn-session-routing.ts
+async function loadConversationChain(conversationId, conversationStore) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cursor = conversationId;
+  while (cursor && !seen.has(cursor)) {
+    seen.add(cursor);
+    const conversation = await conversationStore.get({
+      conversationId: cursor
+    });
+    if (!conversation) {
+      break;
+    }
+    chain.push(conversation);
+    cursor = conversation.lineage?.parentConversationId;
+  }
+  return chain;
+}
+function slackSourceForDestination(args) {
+  if (args.source?.platform !== "slack" || args.source.channelId !== args.destination.channelId) {
+    return void 0;
+  }
+  const threadTs = args.source.threadTs?.trim();
+  return {
+    platform: "slack",
+    visibility: args.source.visibility ?? "public",
+    teamId: args.source.teamId?.trim() || args.destination.teamId,
+    channelId: args.source.channelId,
+    ...threadTs ? { threadTs } : void 0
+  };
+}
+async function resolveConversationRouting(args) {
+  const conversationStore = args.conversationStore ?? (await import("./db-FBHAWVXU.js")).getConversationStore();
+  const chain = await loadConversationChain(
+    args.conversationId,
+    conversationStore
+  );
+  let destination;
+  let source;
+  let location;
+  for (const conversation of chain) {
+    destination ??= conversation.destination;
+    source ??= conversation.sessionSource;
+    location ??= conversation.location;
+    if (destination && source) {
+      break;
+    }
+  }
+  if (!destination) {
+    return void 0;
+  }
+  if (destination.platform === "slack") {
+    const slackSource = slackSourceForDestination({ destination, source });
+    return {
+      destination,
+      ...location ? { location } : void 0,
+      ...slackSource ? { source: slackSource } : void 0
+    };
+  }
+  return {
+    destination,
+    ...location ? { location } : void 0,
+    ...source ? { source } : void 0
+  };
+}
+async function resolveTurnSessionRouting(args) {
+  const routing = await resolveConversationRouting(args);
+  if (!routing?.destination || !routing.source) {
+    throw new Error(
+      `Conversation ${args.conversationId} is missing durable routing metadata`
+    );
+  }
+  return {
+    destination: routing.destination,
+    source: routing.source,
+    ...routing.location ? { location: routing.location } : void 0
+  };
+}
+
 export {
   configValueSchema,
   coerceThreadConversationState,
@@ -512,5 +594,7 @@ export {
   persistThreadRuntimeState,
   getPersistedThreadState,
   persistThreadStateById,
-  getLocationConfigurationService
+  getLocationConfigurationService,
+  resolveConversationRouting,
+  resolveTurnSessionRouting
 };

package/dist/{chunk-TVVAMOLS.js → chunk-2VUDJGB6.js}

@@ -1,10 +1,10 @@
 import {
   createAndEnqueueAgentInvocation
-} from "./chunk-HJPC32TQ.js";
+} from "./chunk-KRYJ5VOD.js";
 import {
   actorFromRun,
   toolInvocationDestination
-} from "./chunk-INQHUE72.js";
+} from "./chunk-6FGN7ZEG.js";
 
 // src/chat/agent-invocations/spawn.ts
 function bindSpawnAgent(run, options) {

package/dist/{chunk-X7NCJQAA.js → chunk-4A2R3AQB.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   toOptionalString
-} from "./chunk-OMQ2J6F6.js";
+} from "./chunk-6YCIYOVA.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";