@sentry/junior 0.115.0 → 0.116.1

package/dist/{catalog-runtime-Y32UEQLB.js → catalog-runtime-WMPC4J4U.js}

@@ -1,17 +1,17 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-6FKLPVF3.js";
-import "./chunk-EW5MLKT5.js";
+} from "./chunk-OY2PQQ4P.js";
+import "./chunk-XA3VLFPK.js";
 import "./chunk-W3U3YQYI.js";
 import "./chunk-HZF5P5UN.js";
-import "./chunk-NVUQSFWX.js";
+import "./chunk-F3SWGSPG.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-F3B2YJ76.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";
 import "./chunk-3V7OFJZC.js";
-import "./chunk-TVE25LPW.js";
-import "./chunk-FHC4JUSF.js";
+import "./chunk-WLT72MRP.js";
+import "./chunk-N3C4XCRE.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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

@@ -77,6 +77,7 @@ export interface AgentRunRouting {
     surface?: AgentTurnSurface;
     dispatch?: {
         actor?: SystemActor;
+        id: string;
         metadata?: Record<string, string>;
         plugin?: string;
     };

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

@@ -23,6 +23,7 @@ type SessionRecordLogContext = NonNullable<Parameters<typeof persistRunningSessi
 interface ResumeStateArgs {
     channelName?: string;
     destination: Destination;
+    dispatchId?: string;
     durability: AgentRunDurability;
     getLoadedSkillNames: () => string[];
     getModelId: () => string;

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

@@ -36,6 +36,7 @@ export interface AgentSandbox {
     readonly tools: SandboxTools;
     readonly workspace: SandboxWorkspace;
     sandboxRef(): SandboxRef | undefined;
+    close(): void;
     writeGeneratedArtifacts(files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;
 }
 /** Create run-scoped sandbox capabilities adapted to the current agent context. */

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

@@ -68,6 +68,7 @@ export interface ToolWiring {
     mcpToolManager: McpToolManager;
     pluginHooks: PluginHookRunner;
     getSandboxRef: () => SandboxRef | undefined;
+    close(): Promise<void>;
     toolGuidance: Array<{
         name: string;
         promptGuidelines: AnyToolDefinition["promptGuidelines"];

package/dist/chat/agent-dispatch/context.d.ts

@@ -1,6 +1,8 @@
 import type { HeartbeatHookContext, PluginRegistration } from "@sentry/junior-plugin-api";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 /** Build the plugin-scoped heartbeat context that gates durable dispatch access. */
 export declare function createHeartbeatContext(args: {
+    conversationWorkQueue: ConversationWorkQueue;
     nowMs: number;
     plugin: string | PluginRegistration;
 }): HeartbeatHookContext;

package/dist/chat/agent-dispatch/heartbeat.d.ts

@@ -1,14 +1,20 @@
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
-/** Re-drive stale core dispatches before invoking plugin heartbeat hooks. */
-export declare function recoverStaleDispatches(args: {
-    limit?: number;
-    nowMs: number;
-}): Promise<number>;
 /** Run plugin heartbeat hooks with bounded per-invocation work. */
 export declare function runPluginHeartbeats(args: {
+    conversationWorkQueue: ConversationWorkQueue;
     limit?: number;
     nowMs: number;
 }): Promise<void>;
+/**
+ * Repair bounded dispatch mailbox appends, including pre-cutover records.
+ *
+ * This index is only an ingress receipt; conversation work owns execution,
+ * leases, retries, and continuation after the mailbox append succeeds.
+ */
+export declare function recoverPendingDispatchMailboxAppends(args: {
+    conversationWorkQueue: ConversationWorkQueue;
+    nowMs: number;
+}): Promise<void>;
 /** Run the core heartbeat phases. */
 export declare function runHeartbeat(args: {
     conversationWorkQueue?: ConversationWorkQueue;

package/dist/chat/agent-dispatch/signing.d.ts

@@ -1,5 +1,14 @@
-import type { DispatchCallback } from "./types";
-/** Schedule an authenticated internal callback to run a dispatched agent slice. */
-export declare function scheduleDispatchCallback(callback: DispatchCallback): Promise<void>;
-/** Verify and parse an authenticated agent dispatch callback request. */
-export declare function verifyDispatchCallbackRequest(request: Request): Promise<DispatchCallback | undefined>;
+import { z } from "zod";
+declare const legacyDispatchCallbackSchema: z.ZodObject<{
+    expectedVersion: z.ZodNumber;
+    id: z.ZodString;
+}, z.core.$strict>;
+type LegacyDispatchCallback = z.infer<typeof legacyDispatchCallbackSchema>;
+/**
+ * Verify callbacks emitted before dispatches moved to conversation work.
+ *
+ * TODO(v0.116.0): Remove the legacy callback route after v0.114.x callbacks
+ * can no longer arrive.
+ */
+export declare function verifyDispatchCallbackRequest(request: Request): Promise<LegacyDispatchCallback | undefined>;
+export {};

package/dist/chat/agent-dispatch/store.d.ts

@@ -1,21 +1,25 @@
-import type { StateAdapter } from "chat";
-import { type SlackDestination } from "@sentry/junior-plugin-api";
 import type { BoundDispatchOptions, DispatchCreateResult, DispatchProjection, DispatchRecord, DispatchStatus } from "./types";
-/** Keep dispatch persistence keys consistent across callback and recovery paths. */
+/** Return the durable key for one plugin-facing dispatch projection. */
 export declare function getDispatchStorageKey(id: string): string;
-/** Parse persisted dispatch records before recovery, callbacks, or projections use them. */
+/** Parse current and rollout-compatible dispatch projection records. */
 export declare function parseDispatchRecord(value: unknown): DispatchRecord | undefined;
-/** Map a dispatch destination to the lock key that serializes Slack delivery. */
-export declare function getDispatchDestinationLockId(destination: SlackDestination): string;
-/** Return the isolated persisted conversation key for one dispatch run. */
+/** Return the isolated durable conversation id for one dispatch. */
 export declare function getDispatchConversationId(dispatch: Pick<DispatchRecord, "id">): string;
-/** Give dispatch slices stable turn ids for resumability and trace correlation. */
+/** Return the stable synthetic input message id for one dispatch turn. */
+export declare function getDispatchInputMessageId(dispatchId: string): string;
+/**
+ * Return the synthetic input id written by the pre-conversation-work runner.
+ *
+ * TODO(v0.116.0): Remove after v0.114 dispatch sessions can no longer resume.
+ */
+export declare function getLegacyDispatchInputMessageId(dispatchId: string): string;
+/** Return every persisted input id accepted while resuming one dispatch. */
+export declare function getDispatchInputMessageIds(dispatchId: string): readonly string[];
+/** Return the stable turn id used by every run of one dispatch. */
 export declare function getDispatchTurnId(dispatchId: string): string;
 /** Gate recovery to dispatches that can still make progress. */
 export declare function isTerminalDispatchStatus(status: DispatchStatus): boolean;
-/** Serialize mutations for a dispatch so callbacks and heartbeats stay idempotent. */
-export declare function withDispatchLock<T>(dispatchId: string, callback: (state: StateAdapter) => Promise<T>): Promise<T>;
-/** Load dispatch state for callback, recovery, and plugin projection paths. */
+/** Load dispatch state for conversation work and plugin projections. */
 export declare function getDispatchRecord(id: string): Promise<DispatchRecord | undefined>;
 /** Create a plugin dispatch idempotently from the plugin's idempotency key. */
 export declare function createOrGetDispatch(args: {
@@ -23,10 +27,27 @@ export declare function createOrGetDispatch(args: {
     options: BoundDispatchOptions;
     plugin: string;
 }): Promise<DispatchCreateResult>;
-/** Advance dispatch versions so stale callbacks cannot overwrite newer state. */
-export declare function updateDispatchRecord(state: StateAdapter, record: DispatchRecord): Promise<DispatchRecord>;
-/** Feed heartbeat recovery from the durable incomplete-dispatch index. */
-export declare function listIncompleteDispatchIds(): Promise<string[]>;
+/** Mark a dispatch projection as actively running. */
+export declare function markDispatchRunning(id: string): Promise<DispatchRecord | undefined>;
+/** Project a durable awaiting-resume turn state to the plugin API. */
+export declare function markDispatchAwaitingResume(id: string): Promise<DispatchRecord | undefined>;
+/** Project a blocked turn to the plugin API. */
+export declare function markDispatchBlocked(id: string, errorMessage: string, resultMessageTs?: string): Promise<DispatchRecord | undefined>;
+/** Project a completed turn and its accepted Slack message to the plugin API. */
+export declare function markDispatchCompleted(id: string, resultMessageTs?: string): Promise<DispatchRecord | undefined>;
+/** Project a terminal conversation turn failure to the plugin API. */
+export declare function markDispatchFailed(id: string, errorMessage: string, resultMessageTs?: string): Promise<DispatchRecord | undefined>;
+/** Remove a dispatch after its durable mailbox append has succeeded. */
+export declare function confirmDispatchMailboxAppend(id: string): Promise<void>;
+/** List dispatches whose durable mailbox append may not have completed. */
+export declare function listPendingDispatchMailboxAppends(): Promise<string[]>;
+/**
+ * Atomically move a rollout-era record behind conversation-owned execution.
+ *
+ * Rewriting the canonical record under the dispatch lock removes the callback
+ * version/lease claim before mailbox work can become visible.
+ */
+export declare function claimDispatchMailboxAppend(id: string, nowMs: number): Promise<DispatchRecord | undefined>;
 /** Return a plugin-scoped dispatch projection without exposing raw runtime state. */
 export declare function getPluginDispatchProjection(args: {
     id: string;

package/dist/chat/agent-dispatch/types.d.ts

@@ -1,5 +1,8 @@
 import type { DispatchOptions, DestinationVisibility, Source, SlackDestination } from "@sentry/junior-plugin-api";
-import type { CredentialSubject, CredentialSystemActor } from "@/chat/credentials/context";
+import type { CredentialContext, CredentialSubject, CredentialSystemActor } from "@/chat/credentials/context";
+import type { AgentRunRouting } from "@/chat/agent/request";
+import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
 export type DispatchStatus = "pending" | "running" | "awaiting_resume" | "completed" | "failed" | "blocked";
 export type SlackDispatchOptions = Omit<DispatchOptions, "destination"> & {
     destination: SlackDestination;
@@ -9,7 +12,6 @@ export interface BoundDispatchOptions extends Omit<SlackDispatchOptions, "creden
 }
 export interface DispatchRecord {
     actor: CredentialSystemActor;
-    attempt: number;
     createdAtMs: number;
     credentialSubject?: CredentialSubject;
     destination: SlackDestination;
@@ -18,16 +20,12 @@ export interface DispatchRecord {
     id: string;
     idempotencyKey: string;
     input: string;
-    lastCallbackAtMs?: number;
-    leaseExpiresAtMs?: number;
-    maxAttempts: number;
     metadata?: Record<string, string>;
     plugin: string;
     resultMessageTs?: string;
     source: Source;
     status: DispatchStatus;
     updatedAtMs: number;
-    version: number;
 }
 export interface DispatchProjection {
     errorMessage?: string;
@@ -35,11 +33,26 @@ export interface DispatchProjection {
     resultMessageTs?: string;
     status: DispatchStatus;
 }
-export interface DispatchCallback {
-    expectedVersion: number;
-    id: string;
-}
 export interface DispatchCreateResult {
     record: DispatchRecord;
     status: "created" | "already_exists";
 }
+export type DispatchTurnOutcome = "awaiting_resume" | "blocked" | "completed" | "failed";
+/** Facts returned by one attempt to advance a dispatched turn. */
+export interface DispatchTurnResult {
+    errorMessage?: string;
+    outcome?: DispatchTurnOutcome;
+    resultMessageTs?: string;
+}
+/** Dispatch-owned authority supplied to the shared turn runtime. */
+export interface DispatchTurnContext {
+    authorizationFlowMode: "disabled";
+    channelConfiguration: ChannelConfigurationService;
+    credentialContext: CredentialContext;
+    destinationVisibility: DestinationVisibility;
+    dispatch: NonNullable<AgentRunRouting["dispatch"]>;
+    skipProviderDefaultConfig: true;
+    source: Source;
+    surface: Extract<AgentTurnSurface, "api">;
+    turnId: string;
+}

package/dist/chat/agent-dispatch/work.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Plugin dispatch mailbox adapter.
+ *
+ * Dispatch metadata selects exact authority and maintains the plugin-facing
+ * projection. The shared conversation worker and turn runtime own execution,
+ * leases, retries, continuation, delivery, and recovery.
+ */
+import type { StateAdapter } from "chat";
+import type { ConversationStore } from "@/chat/conversations/store";
+import { type InboundMessage } from "@/chat/task-execution/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
+import type { DispatchRecord, DispatchTurnContext, DispatchTurnResult } from "./types";
+export declare const AGENT_DISPATCH_MAX_AGE_MS: number;
+type DispatchRoutingContext = Pick<DispatchTurnContext, "credentialContext" | "destinationVisibility" | "dispatch" | "surface"> & {
+    actor: DispatchRecord["actor"];
+};
+/** Restore the exact actor, credential, and dispatch routing for every slice. */
+export declare function buildDispatchRoutingContext(dispatch: DispatchRecord): DispatchRoutingContext;
+interface EnqueueAgentDispatchOptions {
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}
+/** Dependencies for dispatch work owned by the conversation worker. */
+export interface AgentDispatchConversationWorkerOptions {
+    resumeTurn: (dispatch: DispatchRecord, hooks: {
+        shouldYield?: () => boolean;
+    }) => Promise<void>;
+    runTurn: (dispatch: DispatchRecord, hooks: {
+        ack: () => Promise<void>;
+        shouldYield?: () => boolean;
+    }) => Promise<DispatchTurnResult>;
+}
+/** Build the stable mailbox work item for one plugin dispatch. */
+export declare function buildAgentDispatchInboundMessage(dispatch: DispatchRecord, nowMs?: number): InboundMessage;
+/** Persist dispatch mailbox work before sending its conversation wake-up. */
+export declare function enqueueAgentDispatch(dispatch: DispatchRecord, options: EnqueueAgentDispatchOptions): Promise<void>;
+/**
+ * Resolve a dispatch from concrete mailbox metadata or the active turn.
+ *
+ * Provider source and conversation-id conventions are deliberately not
+ * execution routing authority.
+ */
+export declare function resolveAgentDispatchId(context: ConversationWorkerContext): Promise<string | undefined>;
+/**
+ * Route leased work through dispatch execution when durable metadata owns it.
+ *
+ * The fallback retains ownership of every other conversation source.
+ */
+export declare function createAgentDispatchWorkRouter(options: {
+    dispatchWorker: (context: ConversationWorkerContext, dispatchId: string) => Promise<ConversationWorkerResult>;
+    fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
+}): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
+/** Run one dispatch start or resume under the owning conversation lease. */
+export declare function createAgentDispatchConversationWorker(options: AgentDispatchConversationWorkerOptions): (context: ConversationWorkerContext, dispatchId: string) => Promise<ConversationWorkerResult>;
+export {};

package/dist/chat/app/factory.d.ts

@@ -1,10 +1,19 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
-import { type AssistantLifecycleEvent, type SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { Message } from "chat";
+import { type AssistantLifecycleEvent } from "@/chat/runtime/slack-runtime";
 import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
-import { type PreparedTurnState } from "@/chat/runtime/turn-preparation";
 export interface CreateSlackRuntimeOptions {
     getSlackAdapter: () => SlackAdapter;
     now?: () => number;
     services?: JuniorRuntimeServiceOverrides;
 }
-export declare function createSlackRuntime(options: CreateSlackRuntimeOptions): SlackTurnRuntime<PreparedTurnState, AssistantLifecycleEvent>;
+export declare function createSlackRuntime(options: CreateSlackRuntimeOptions): {
+    runDispatchTurn: (dispatch: import("../agent-dispatch/types").DispatchRecord, hooks: {
+        ack: () => Promise<void>;
+        shouldYield?: () => boolean;
+    }) => Promise<import("../agent-dispatch/types").DispatchTurnResult>;
+    handleAssistantContextChanged: (event: AssistantLifecycleEvent) => Promise<void>;
+    handleAssistantThreadStarted: (event: AssistantLifecycleEvent) => Promise<void>;
+    handleNewMention: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/runtime/slack-runtime").SlackTurnOptions) => Promise<void>;
+    handleSubscribedMessage: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/runtime/slack-runtime").SlackTurnOptions) => Promise<void>;
+};