@sentry/junior 0.184.0 → 0.185.0

package/dist/{catalog-runtime-5357XR4F.js → catalog-runtime-AAEAO2RL.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
-import "./chunk-LHXIZLFF.js";
+} from "./chunk-GJTIZQGJ.js";
+import "./chunk-7MHNIGHP.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-3S7ULUWW.js";
+import "./chunk-OMQ2J6F6.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-6VOYP4M6.js";
+import "./chunk-7GAP2XG4.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/api-turns/accepted-reply.d.ts

@@ -0,0 +1,11 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+/** Record a web-accepted assistant reply with agent history before the visible message. */
+export declare function commitWebAcceptedReply(args: {
+    agentMessage?: AssistantMessage;
+    conversation: ThreadConversationState;
+    conversationId: string;
+    sessionId: string;
+    text: string;
+    userMessageId: string;
+}): Promise<void>;

package/dist/chat/api-turns/cancellation.d.ts

@@ -1,4 +1,4 @@
-/** App-scoped control for one active API Turn per Conversation. */
+/** App-scoped control for one active Turn started by the Conversation API. */
 export interface ApiTurnCancellation {
     begin(conversationId: string): AbortSignal | undefined;
     cancel(conversationId: string): boolean;
@@ -7,21 +7,19 @@ export interface ApiTurnCancellation {
     park(conversationId: string, signal: AbortSignal): void;
     signal(conversationId: string): AbortSignal | undefined;
 }
-/** Create in-process cancellation state for active API Turns. */
+/** Create in-process cancellation state for Turns from the Conversation API. */
 export declare function createApiTurnCancellation(): ApiTurnCancellation;
-/** Close one cancelled API Turn without a failure reply or retry. */
+/** Close one cancelled Turn without a failure reply or retry. */
 export declare function completeCancelledApiTurn(args: {
     acknowledge(): Promise<void>;
     actorId: string;
     cancellation?: ApiTurnCancellation;
     conversation: ThreadConversationState;
     conversationId: string;
-    lifecycle: ConversationTurnLifecycle;
     sandboxRef?: SandboxRef;
     signal?: AbortSignal;
     turnId: string;
     userMessageId: string;
 }): Promise<void>;
-import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import type { SandboxRef } from "@/chat/sandbox/ref";
 import type { ThreadConversationState } from "@/chat/state/conversation";

package/dist/chat/api-turns/work.d.ts

@@ -3,7 +3,6 @@ import { type Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { WebActor } from "@/chat/actor";
 import type { ConversationStore } from "@/chat/conversations/store";
-import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { type InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
@@ -86,18 +85,14 @@ export declare function recordApiConversationActivity(args: {
 }): Promise<Destination>;
 /** Create a dashboard root conversation and enqueue its first message. */
 export declare function createAndEnqueueApiConversation(input: CreateApiConversationInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
-/** Append one API message and optionally require an idle Conversation. */
+/** Append one Conversation API message and optionally require an idle Conversation. */
 export declare function appendAndEnqueueApiConversationMessage(input: AppendApiConversationMessageInput, options: EnqueueOptions & {
     exclusive: true;
 }): Promise<ApiConversationMessageAdmission>;
 export declare function appendAndEnqueueApiConversationMessage(input: AppendApiConversationMessageInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
-/** Build the mailbox consumer for API-authored root turns. */
-export declare function createApiTurnWorker(options: {
-    agentRunner: AgentRunner;
-    cancellation?: ApiTurnCancellation;
-    turnLifecycle?: ConversationTurnLifecycle;
-}): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
-/** Route API turn work before falling through to other consumers. */
+/** Create the worker for messages from the Conversation API. */
+export declare function createApiTurnWorker(agentRunner: AgentRunner, cancellation?: ApiTurnCancellation): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
+/** Route Conversation API work before other work. */
 export declare function routeApiTurnWork(options: {
     apiTurnWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
     fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;

package/dist/chat/app/conversation-work.d.ts

@@ -16,7 +16,7 @@ interface ConversationWorkOptions {
     state?: StateAdapter;
 }
 export type ConversationWorkCallbackOptions = VercelConversationWorkCallbackOptions & {
-    /** App-scoped control for API Turn cancellation across request handlers. */
+    /** App-scoped Turn cancellation for Conversation API request handlers. */
     apiTurnCancellation?: ApiTurnCancellation;
 };
 /**

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

@@ -2,9 +2,13 @@ import type { SlackAdapter } from "@chat-adapter/slack";
 import type { Message } from "chat";
 import { type AssistantLifecycleEvent } from "@/chat/providers/slack/runtime";
 import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
+import type { ScheduleSessionCompletedPluginTasksOptions } from "@/chat/plugins/task-runner";
+import { type PausedTurns } from "@/chat/task-execution/turn-wake";
 export interface CreateSlackRuntimeOptions {
     getSlackAdapter: () => SlackAdapter;
     now?: () => number;
+    pausedTurns?: PausedTurns;
+    sendPluginTask?: ScheduleSessionCompletedPluginTasksOptions["send"];
     services?: JuniorRuntimeServiceOverrides;
 }
 export declare function createSlackRuntime(options: CreateSlackRuntimeOptions): {

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

@@ -2,19 +2,20 @@ import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/
 import { type ConversationMemoryDeps, type ConversationMemoryService } from "@/chat/services/conversation-memory";
 import { type ContextCompactor, type ContextCompactorDeps } from "@/chat/services/context-compaction";
 import { type SubscribedReplyPolicy, type SubscribedReplyPolicyDeps } from "@/chat/services/subscribed-reply-policy";
-import type { SlackTurnServices } from "@/chat/providers/slack/turn";
 import { type VisionContextDeps, type VisionContextService } from "@/chat/slack/vision-context";
+import { type AgentRunner } from "@/chat/runtime/agent-runner";
+import { type ExecuteTurn } from "@/chat/runtime/turn-execution";
 export interface JuniorRuntimeServices {
     conversationMemory: ConversationMemoryService;
     contextCompactor: ContextCompactor;
-    replyExecutor: SlackTurnServices;
+    executeTurn: ExecuteTurn;
     subscribedReplyPolicy: SubscribedReplyPolicy;
     visionContext: VisionContextService;
 }
 export interface JuniorRuntimeServiceOverrides {
+    agentRunner?: AgentRunner;
     conversationMemory?: Partial<ConversationMemoryDeps>;
     contextCompactor?: Partial<ContextCompactorDeps>;
-    replyExecutor?: Partial<SlackTurnServices>;
     subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
     sandbox?: {
         tracePropagation?: SandboxEgressTracePropagationConfig;

package/dist/chat/conversations/history.d.ts

@@ -165,18 +165,41 @@ export type AuthorizationKind = z.output<typeof authorizationKindSchema>;
 export declare const conversationTurnSurfaceSchema: z.ZodEnum<{
     slack: "slack";
     api: "api";
-    internal: "internal";
     scheduler: "scheduler";
+    internal: "internal";
 }>;
-/** Stable, privacy-safe classification for a failed turn. */
+/** Where a failed turn stopped. */
 export declare const conversationTurnFailureCodeSchema: z.ZodEnum<{
     agent_run_failed: "agent_run_failed";
     delivery_failed: "delivery_failed";
     model_execution_failed: "model_execution_failed";
     persistence_failed: "persistence_failed";
 }>;
-/** Failure classification persisted without raw provider or exception data. */
+/** Where a failed turn stopped. */
 export type ConversationTurnFailureCode = z.output<typeof conversationTurnFailureCodeSchema>;
+/**
+ * Why a failed turn stopped.
+ * Values are fixed labels only. Do not store raw exception text.
+ */
+export declare const conversationTurnFailureReasonSchema: z.ZodEnum<{
+    unknown: "unknown";
+    auth: "auth";
+    permission: "permission";
+    rate_limit: "rate_limit";
+    capacity: "capacity";
+    timeout: "timeout";
+    network: "network";
+    server: "server";
+    invalid_request: "invalid_request";
+    invalid_response: "invalid_response";
+    quota: "quota";
+    content_policy: "content_policy";
+    empty_output: "empty_output";
+    tool_errors: "tool_errors";
+    suppressed_output: "suppressed_output";
+}>;
+/** Why a failed turn stopped. */
+export type ConversationTurnFailureReason = z.output<typeof conversationTurnFailureReasonSchema>;
 /** Strict event-data contract reused by the SQL row codec. */
 export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"message">;
@@ -290,8 +313,8 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     surface: z.ZodEnum<{
         slack: "slack";
         api: "api";
-        internal: "internal";
         scheduler: "scheduler";
+        internal: "internal";
     }>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"turn_context">;
@@ -341,8 +364,8 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     turnId: z.ZodString;
     outcome: z.ZodEnum<{
         success: "success";
-        no_reply: "no_reply";
         cancelled: "cancelled";
+        no_reply: "no_reply";
     }>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"turn_failed">;
@@ -353,6 +376,23 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
         model_execution_failed: "model_execution_failed";
         persistence_failed: "persistence_failed";
     }>;
+    failureReason: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        auth: "auth";
+        permission: "permission";
+        rate_limit: "rate_limit";
+        capacity: "capacity";
+        timeout: "timeout";
+        network: "network";
+        server: "server";
+        invalid_request: "invalid_request";
+        invalid_response: "invalid_response";
+        quota: "quota";
+        content_policy: "content_policy";
+        empty_output: "empty_output";
+        tool_errors: "tool_errors";
+        suppressed_output: "suppressed_output";
+    }>>;
     eventId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"subagent_started">;
@@ -606,8 +646,8 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         surface: z.ZodEnum<{
             slack: "slack";
             api: "api";
-            internal: "internal";
             scheduler: "scheduler";
+            internal: "internal";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_context">;
@@ -657,8 +697,8 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         turnId: z.ZodString;
         outcome: z.ZodEnum<{
             success: "success";
-            no_reply: "no_reply";
             cancelled: "cancelled";
+            no_reply: "no_reply";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_failed">;
@@ -669,6 +709,23 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             model_execution_failed: "model_execution_failed";
             persistence_failed: "persistence_failed";
         }>;
+        failureReason: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            auth: "auth";
+            permission: "permission";
+            rate_limit: "rate_limit";
+            capacity: "capacity";
+            timeout: "timeout";
+            network: "network";
+            server: "server";
+            invalid_request: "invalid_request";
+            invalid_response: "invalid_response";
+            quota: "quota";
+            content_policy: "content_policy";
+            empty_output: "empty_output";
+            tool_errors: "tool_errors";
+            suppressed_output: "suppressed_output";
+        }>>;
         eventId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"subagent_started">;
@@ -945,8 +1002,8 @@ export declare const newConversationEventSchema: z.ZodObject<{
         surface: z.ZodEnum<{
             slack: "slack";
             api: "api";
-            internal: "internal";
             scheduler: "scheduler";
+            internal: "internal";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_context">;
@@ -996,8 +1053,8 @@ export declare const newConversationEventSchema: z.ZodObject<{
         turnId: z.ZodString;
         outcome: z.ZodEnum<{
             success: "success";
-            no_reply: "no_reply";
             cancelled: "cancelled";
+            no_reply: "no_reply";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_failed">;
@@ -1008,6 +1065,23 @@ export declare const newConversationEventSchema: z.ZodObject<{
             model_execution_failed: "model_execution_failed";
             persistence_failed: "persistence_failed";
         }>;
+        failureReason: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            auth: "auth";
+            permission: "permission";
+            rate_limit: "rate_limit";
+            capacity: "capacity";
+            timeout: "timeout";
+            network: "network";
+            server: "server";
+            invalid_request: "invalid_request";
+            invalid_response: "invalid_response";
+            quota: "quota";
+            content_policy: "content_policy";
+            empty_output: "empty_output";
+            tool_errors: "tool_errors";
+            suppressed_output: "suppressed_output";
+        }>>;
         eventId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"subagent_started">;

package/dist/chat/conversations/turn-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { ConversationEventStore, ConversationTurnFailureCode } from "./history";
+import type { ConversationEventStore, ConversationTurnFailureCode, ConversationTurnFailureReason } from "./history";
 /** Product-owned inputs for opening one correlated conversation turn. */
 export interface StartConversationTurnInput {
     conversationId: string;
@@ -14,12 +14,13 @@ export interface CompleteConversationTurnInput {
     outcome: "success" | "no_reply" | "cancelled";
     turnId: string;
 }
-/** Privacy-safe inputs for failing one correlated conversation turn. */
+/** Inputs for failing one correlated conversation turn. */
 export interface FailConversationTurnInput {
     conversationId: string;
     createdAtMs: number;
     eventId?: string;
     failureCode: ConversationTurnFailureCode;
+    failureReason?: ConversationTurnFailureReason;
     turnId: string;
 }
 /** Runtime port for correlated canonical turn lifecycle persistence. */
@@ -36,6 +37,6 @@ export declare class ConversationTurnLifecycleService implements ConversationTur
     start(input: StartConversationTurnInput): Promise<void>;
     /** Record successful or intentional-silence completion once. */
     complete(input: CompleteConversationTurnInput): Promise<void>;
-    /** Record a classified failure once without accepting raw error details. */
+    /** Record a classified failure once. Do not store raw error text. */
     fail(input: FailConversationTurnInput): Promise<void>;
 }

package/dist/chat/providers/slack/input.d.ts

@@ -0,0 +1,32 @@
+import type { Message, Thread } from "chat";
+import type { AgentSteeringMessage } from "@/chat/agent/types";
+import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { QueuedTurnMessage } from "@/chat/runtime/turn-input";
+/**
+ * Return a stable key for one steering message. Resolved attachments may change
+ * when Junior retries a mailbox delivery, so only the message time and text
+ * form the key.
+ */
+export declare function steeringMessageKey(message: PiMessage): string | undefined;
+/** Add recent Slack messages to the agent context. */
+export declare function appendRecentMessagesToContext(conversationContext: string | undefined, messages: QueuedTurnMessage[]): string | undefined;
+/** Return the actor stored with one inbound Slack message. */
+export declare function inboundMessageActor(queued: QueuedTurnMessage): AgentSteeringMessage["actor"];
+/** Return the authority stored with one inbound Slack message. */
+export declare function inboundMessageProvenance(queued: QueuedTurnMessage, teamId: string): ConversationMessageProvenance;
+/** Return the Slack channel name when it is available. */
+export declare function resolveChannelName(thread: Thread): Promise<string | undefined>;
+/** Collect attachments from the current Slack message and its batch. */
+export declare function collectAttachments(message: Message, batchedMessages?: QueuedTurnMessage[]): Message["attachments"];
+/**
+ * Save each steering message once. Return false when a resumed Run is active
+ * so the mailbox delivery stays pending.
+ */
+export declare function saveSteeringMessages(args: {
+    conversationId: string;
+    messages: Array<{
+        message: PiMessage;
+        provenance: ConversationMessageProvenance;
+    }>;
+}): Promise<boolean>;

package/dist/chat/{runtime → providers/slack}/processing-reaction.d.ts

@@ -2,22 +2,20 @@ import type { Message, Thread } from "chat";
 import type { TurnToolInvocation } from "@/chat/runtime/turn-input";
 import type { SlackMessageTs } from "@/chat/slack/timestamp";
 /** Controls the automatic Slack processing reaction lifecycle for one message. */
-export interface ProcessingReactionSession {
+export interface ProcessingReaction {
     complete: () => Promise<void>;
     keep: () => void;
     stop: () => Promise<void>;
 }
-/** Return true when a Slack reaction tool call should leave the processing reaction in place. */
+/** Return true when a Slack reaction tool invocation keeps the processing reaction. */
 export declare function shouldKeepProcessingReactionForToolInvocation(input: TurnToolInvocation): boolean;
 /** Start Junior's automatic Slack processing reaction for one inbound message. */
-export declare function startSlackProcessingReaction(args: {
-    logException: (error: unknown, eventName: string, attributes?: Record<string, unknown>) => string | undefined;
+export declare function startProcessingReaction(args: {
     message: Message;
     thread: Thread;
-}): Promise<ProcessingReactionSession>;
+}): Promise<ProcessingReaction>;
 /** Start Junior's automatic Slack processing reaction for a known Slack message. */
-export declare function startSlackProcessingReactionForMessage(args: {
+export declare function startProcessingReactionForMessage(args: {
     channelId: string;
     timestamp: SlackMessageTs;
-    logException: (error: unknown, eventName: string, attributes?: Record<string, unknown>) => string | undefined;
-}): Promise<ProcessingReactionSession>;
+}): Promise<ProcessingReaction>;

package/dist/chat/{runtime/slack-resume.d.ts → providers/slack/resume.d.ts}

@@ -1,10 +1,10 @@
 import { type AgentRun } from "@/chat/agent/types";
 import type { AgentRunResult } from "@/chat/services/turn-result";
-import { type AgentRunner } from "@/chat/runtime/agent-runner";
-import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
+import { type ExecuteTurn } from "@/chat/runtime/turn-execution";
+import { scheduleSessionCompletedPluginTasks } from "@/chat/plugins/task-runner";
 import { type AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackMessageTs } from "@/chat/slack/timestamp";
-/** Error raised when another worker already owns the resume lock. */
+/** Error raised when another worker is already resuming the Slack Turn. */
 export declare class ResumeTurnBusyError extends Error {
     constructor(lockKey: string);
 }
@@ -17,23 +17,20 @@ interface ResumeSlackTurnArgs {
     channelId: string;
     threadTs?: string;
     messageTs?: SlackMessageTs;
-    replyContext?: ResumeReplyContext;
+    /** Saved Run fields. `beforeStart` may supply them after stale-work checks. */
+    run?: ResumeRun;
     lockKey?: string;
     /**
      * When true, the caller already holds the conversation work lease.
-     * Skip the second resume lock so queue continue is one owner, not two.
-     * OAuth and other out-of-band resumes leave this false.
+     * Skip the second resume lock so the queue continuation has one owner.
+     * Authorization callbacks and other independent resumes leave this false.
      */
     ownsConversationLease?: boolean;
     initialText?: string;
     initialStatus?: AssistantStatusSpec;
-    agentRunner: AgentRunner;
+    executeTurn: ExecuteTurn;
     inputMessageIds?: string[];
-    turnLifecycle?: ConversationTurnLifecycle;
-    scheduleSessionCompletedPluginTasks?: (params: {
-        conversationId: string;
-        sessionId: string;
-    }) => Promise<void>;
+    scheduleSessionCompletedPluginTasks?: typeof scheduleSessionCompletedPluginTasks;
     commitResult?: (result: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
     onAuthPause?: (pause: {
@@ -42,9 +39,8 @@ interface ResumeSlackTurnArgs {
     onSuspend?: (resumeVersion: number) => Promise<void>;
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
     beforeStart?: () => Promise<ResumePreparedTurn | false | void>;
-    replyTimeoutMs?: number;
 }
-type ResumeReplyContext = Omit<AgentRun, "conversationId" | "turnId" | "runId" | "instruction" | "delivery"> & {
+type ResumeRun = Omit<AgentRun, "conversationId" | "turnId" | "runId" | "instruction" | "delivery"> & {
     instruction?: Omit<AgentRun["instruction"], "text">;
 };
 interface ResumePreparedTurn {
@@ -54,7 +50,7 @@ interface ResumePreparedTurn {
     messageTs?: SlackMessageTs;
     inputMessageIds?: string[];
     initialStatus?: AssistantStatusSpec;
-    replyContext: ResumeReplyContext;
+    run: ResumeRun;
     commitResult?: (result: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
     onAuthPause?: (pause: {
@@ -64,11 +60,12 @@ interface ResumePreparedTurn {
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
 }
 /**
- * Resume a paused Slack turn.
+ * Resume a paused Slack Turn.
  *
- * Queue continues pass `ownsConversationLease` and skip the second lock
- * (worker lease is already held). OAuth and other out-of-band resumes still
- * take the thread lock. Started resumes own their completion side effects.
+ * Queue continuations pass `ownsConversationLease` and skip the second lock
+ * because the worker lease is already held. Authorization callbacks and other
+ * independent resumes still take the thread lock. A started resume owns its
+ * completion work.
  * Returns false only when `beforeStart` proves the resume is stale before
  * generation begins.
  */

package/dist/chat/providers/slack/runtime.d.ts

@@ -47,10 +47,8 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
     cancelEventSubscriptions: (input: {
         conversationId: string;
     }) => Promise<void>;
-    getChannelId: (thread: Thread, message: Message) => string | undefined;
+    getBotUserId: () => string | undefined;
     getPreparedConversationContext: (preparedState: TPreparedState) => string | undefined;
-    getThreadId: (thread: Thread, message: Message) => string | undefined;
-    getRunId: (thread: Thread, message: Message) => string | undefined;
     initializeAssistantThread: (event: {
         channelId: string;
         sourceChannelId?: string;
@@ -64,8 +62,6 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         threadId: string;
         threadTs: string;
     }) => Promise<void>;
-    logException: (error: unknown, eventName: string, attributes?: Record<string, unknown>) => string | undefined;
-    logWarn: (eventName: string, attributes?: Record<string, unknown>) => void;
     modelId: string;
     now: () => number;
     recordSkippedSteeringMessage: (args: {
@@ -109,11 +105,6 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         shouldYield?: () => boolean;
     }) => Promise<void>;
     decideSubscribedReply: SubscribedReplyPolicy;
-    stripLeadingBotMention: (text: string, options: {
-        botUserId?: string;
-        stripLeadingSlackMentionToken?: boolean;
-    }) => string;
-    withSpan: (name: string, op: string, context: Record<string, unknown>, callback: () => Promise<void>) => Promise<void>;
 }
 export interface SlackTurnRuntime<_TPreparedState, TAssistantEvent extends AssistantLifecycleEvent = AssistantLifecycleEvent> {
     handleAssistantContextChanged: (event: TAssistantEvent) => Promise<void>;

package/dist/chat/providers/slack/turn.d.ts

@@ -1,39 +1,25 @@
 /**
- * Add Slack provider behavior around one native agent Turn.
+ * Add Slack behavior around one Turn.
  *
- * This module prepares Slack input and owns Slack status, delivery, and saved
- * Slack state. Native execution concerns that remain here must move behind a
- * provider-neutral runtime contract. Agent execution stays behind
- * `AgentRunner`.
+ * This module owns Slack status, delivery, and state.
+ * It calls `executeTurn` to run and finish the Turn.
  */
 import type { Message, Thread } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { type Destination } from "@sentry/junior-plugin-api";
-import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import { type ExecuteTurn } from "@/chat/runtime/turn-execution";
 import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
 import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnToolInvocation } from "@/chat/runtime/turn-input";
 import type { ContextCompactor } from "@/chat/services/context-compaction";
-import { lookupSlackUser } from "@/chat/slack/user";
-import type { PausedTurnRequest } from "@/chat/task-execution/turn-wake";
+import type { PausedTurns } from "@/chat/task-execution/turn-wake";
 import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
+import { type ScheduleSessionCompletedPluginTasksOptions } from "@/chat/plugins/task-runner";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
-export interface SlackTurnServices {
-    agentRunner: AgentRunner;
-    contextCompactor: ContextCompactor;
-    getPausedTurnRequest: (args: {
-        conversationId: string;
-        turnId: string;
-    }) => Promise<PausedTurnRequest | undefined>;
-    lookupSlackUser: typeof lookupSlackUser;
-    turnLifecycle: ConversationTurnLifecycle;
-    wakePausedTurn: (request: PausedTurnRequest) => Promise<void>;
-    scheduleSessionCompletedPluginTasks: (params: {
-        conversationId: string;
-        sessionId: string;
-    }) => Promise<void>;
-}
 interface SlackTurnDeps {
+    contextCompactor: ContextCompactor;
+    executeTurn: ExecuteTurn;
     getSlackAdapter: () => SlackAdapter;
+    pausedTurns: PausedTurns;
     resolveUserAttachments: (attachments: Message["attachments"] | undefined, context: {
         threadId?: string;
         actorId?: string;
@@ -48,7 +34,8 @@ interface SlackTurnDeps {
         promptText?: string;
     }>>;
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;
-    services: SlackTurnServices;
+    sendPluginTask?: ScheduleSessionCompletedPluginTasksOptions["send"];
+    turnLifecycle: Pick<ConversationTurnLifecycle, "fail" | "start">;
 }
 /** Build the Slack caller that prepares input and delivers output for a Turn. */
 export declare function createSlackTurn(deps: SlackTurnDeps): (thread: Thread, message: Message, options: {

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

@@ -23,8 +23,8 @@ declare const subscriptionSchema: z.ZodObject<{
     resourceType: z.ZodString;
     status: z.ZodEnum<{
         completed: "completed";
-        active: "active";
         cancelled: "cancelled";
+        active: "active";
     }>;
     updatedAtMs: z.ZodNumber;
 }, z.core.$strict>;

package/dist/chat/resource-events/tool-support.d.ts

@@ -1,4 +1,3 @@
-import type { ToolRuntimeContext } from "@/chat/tools/types";
 /** Default lifetime for temporary resource subscriptions. */
 export declare const RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS: number;
 /** Hard upper bound for temporary resource subscriptions. */
@@ -8,7 +7,3 @@ export declare const RESOURCE_WATCH_TOOL_SOURCE: {
     id: string;
     description: string;
 };
-/** Require the Slack thread identity that owns a resource watch. */
-export declare function requireResourceWatchConversation(context: ToolRuntimeContext): string;
-/** Return whether the current runtime can safely manage conversation watches. */
-export declare function canUseResourceEventSubscriptionTools(context: ToolRuntimeContext): boolean;

package/dist/chat/runtime/turn-execution.d.ts

@@ -1,14 +1,16 @@
 import type { AgentRun } from "@/chat/agent/types";
 import type { CompleteConversationTurnInput, FailConversationTurnInput } from "@/chat/conversations/turn-lifecycle";
 import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
-import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import { type AgentRunner } from "@/chat/runtime/agent-runner";
 import type { AgentRunResult } from "@/chat/services/turn-result";
 type SavedTurnResult = {
     finishedAtMs?: number;
     outcome: CompleteConversationTurnInput["outcome"];
 } | {
+    eventId?: string;
     finishedAtMs?: number;
     failureCode: FailConversationTurnInput["failureCode"];
+    failureReason?: FailConversationTurnInput["failureReason"];
     outcome: "failed";
 };
 type TurnExecutionOutcome = Exclude<AgentRunOutcome, {
@@ -25,6 +27,9 @@ export declare class AgentRunError extends Error {
  *
  * A paused Run, or a Run waiting for authorization, leaves the Turn open. A
  * save error also leaves the Turn open so the worker can retry or recover it.
+ * A timeout aborts the Run before this function reports the failure.
  */
-export declare function executeTurn(agentRunner: AgentRunner, run: AgentRun, saveResult: (result: AgentRunResult) => Promise<SavedTurnResult>): Promise<TurnExecutionOutcome>;
+export declare function executeTurn(agentRunner: AgentRunner, run: AgentRun, saveResult: (result: AgentRunResult) => Promise<SavedTurnResult>, timeoutMs?: number): Promise<TurnExecutionOutcome>;
+/** Run the agent and finish a Turn after its caller saves the result. */
+export type ExecuteTurn = (run: AgentRun, saveResult: (result: AgentRunResult) => Promise<SavedTurnResult>, timeoutMs?: number) => Promise<TurnExecutionOutcome>;
 export {};