@sentry/junior 0.72.0 → 0.74.0

package/dist/chat/state/turn-session.d.ts

@@ -2,6 +2,7 @@ import type { Destination } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
 import { type StoredSlackRequester } from "@/chat/requester";
 import type { AgentTurnUsage } from "@/chat/usage";
+import type { ConversationStore } from "@/chat/conversations/store";
 export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "abandoned";
 export type AgentTurnSurface = "slack" | "api" | "scheduler" | "internal";
 export type AgentTurnResumeReason = "timeout" | "auth" | "yield";
@@ -40,6 +41,7 @@ export declare function upsertAgentTurnSessionRecord(args: {
     destination?: Destination;
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
+    conversationStore?: ConversationStore;
     sessionId: string;
     sliceId: number;
     state: AgentTurnSessionStatus;
@@ -62,6 +64,7 @@ export declare function recordAgentTurnSessionSummary(args: {
     destination?: Destination;
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
+    conversationStore?: ConversationStore;
     requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     sessionId: string;

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

@@ -1,6 +1,7 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { Message, ThreadImpl, type SerializedMessage, type SerializedThread, type StateAdapter } from "chat";
 import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { ConversationStore } from "@/chat/conversations/store";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
@@ -18,6 +19,7 @@ export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
     resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
+    conversationStore?: ConversationStore;
     runtime: Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
     state?: StateAdapter;
 }

package/dist/chat/task-execution/state.d.ts

@@ -0,0 +1,209 @@
+import type { StateAdapter } from "chat";
+import type { Destination } from "@sentry/junior-plugin-api";
+import { type StoredSlackRequester } from "@/chat/requester";
+export declare const CONVERSATION_BY_ACTIVITY_INDEX_KEY = "junior:conversation:by-activity";
+export declare const CONVERSATION_ACTIVE_INDEX_KEY = "junior:conversation:active";
+export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
+export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
+export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
+export type Source = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+export type ExecutionStatus = "awaiting_resume" | "idle" | "pending" | "running";
+export interface AgentInput {
+    attachments?: unknown[];
+    authorId?: string;
+    metadata?: Record<string, unknown>;
+    text: string;
+}
+export interface InboundMessage {
+    conversationId: string;
+    createdAtMs: number;
+    destination: Destination;
+    inboundMessageId: string;
+    injectedAtMs?: number;
+    input: AgentInput;
+    receivedAtMs: number;
+    source: Source;
+}
+export interface Lease {
+    acquiredAtMs: number;
+    expiresAtMs: number;
+    lastCheckInAtMs: number;
+    token: string;
+}
+export interface ConversationExecution {
+    inboundMessageIds: string[];
+    lastCheckpointAtMs?: number;
+    lastEnqueuedAtMs?: number;
+    lease?: Lease;
+    pendingCount: number;
+    pendingMessages: InboundMessage[];
+    runId?: string;
+    status: ExecutionStatus;
+    updatedAtMs?: number;
+}
+export interface Conversation {
+    channelName?: string;
+    conversationId: string;
+    createdAtMs: number;
+    destination?: Destination;
+    execution: ConversationExecution;
+    lastActivityAtMs: number;
+    requester?: StoredSlackRequester;
+    schemaVersion: 1;
+    source?: Source;
+    title?: string;
+    updatedAtMs: number;
+}
+export interface ConversationWorkLease {
+    acquiredAtMs: number;
+    lastCheckInAtMs: number;
+    leaseExpiresAtMs: number;
+    leaseToken: string;
+}
+export interface ConversationWorkState extends Conversation {
+    lastEnqueuedAtMs?: number;
+    lease?: ConversationWorkLease;
+    messages: InboundMessage[];
+    needsRun: boolean;
+}
+export interface StartConversationWorkAcquired {
+    leaseExpiresAtMs: number;
+    leaseToken: string;
+    status: "acquired";
+}
+export interface StartConversationWorkActive {
+    leaseExpiresAtMs: number;
+    status: "active";
+}
+export interface StartConversationWorkNoWork {
+    status: "no_work";
+}
+export type StartConversationWorkResult = StartConversationWorkAcquired | StartConversationWorkActive | StartConversationWorkNoWork;
+export interface AppendInboundMessageResult {
+    status: "appended" | "duplicate";
+}
+export interface AppendAndEnqueueInboundMessageResult extends AppendInboundMessageResult {
+    queueMessageId?: string;
+}
+export interface RequestConversationWorkResult {
+    status: "created" | "updated";
+}
+/** Return a persisted conversation record, if one exists. */
+export declare function getConversation(args: {
+    conversationId: string;
+    state?: StateAdapter;
+}): Promise<Conversation | undefined>;
+/** Return a persisted conversation work record, if one exists. */
+export declare function getConversationWorkState(args: {
+    conversationId: string;
+    state?: StateAdapter;
+}): Promise<ConversationWorkState | undefined>;
+/** Count mailbox messages that have not yet reached the session log. */
+export declare function countPendingConversationMessages(conversation: Conversation): number;
+/** Return whether a conversation has pending or resumable execution work. */
+export declare function hasRunnableConversationWork(conversation: Conversation): boolean;
+/** Persist one inbound message idempotently in its conversation mailbox. */
+export declare function appendInboundMessage(args: {
+    message: InboundMessage;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<AppendInboundMessageResult>;
+/** Mark a conversation runnable when there is no new mailbox message. */
+export declare function requestConversationWork(args: {
+    conversationId: string;
+    destination: Destination;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<RequestConversationWorkResult>;
+/** Record visible conversation activity without making the conversation runnable. */
+export declare function recordConversationActivity(args: {
+    activityAtMs?: number;
+    channelName?: string;
+    conversationId: string;
+    destination?: Destination;
+    nowMs?: number;
+    requester?: StoredSlackRequester;
+    source?: Source;
+    state?: StateAdapter;
+    title?: string;
+}): Promise<void>;
+/** Record that a wake-up nudge was accepted for the conversation. */
+export declare function markConversationWorkEnqueued(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<void>;
+/** Try to acquire the durable execution lease for one conversation. */
+export declare function startConversationWork(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<StartConversationWorkResult>;
+/** Extend the durable execution lease when the worker checks in. */
+export declare function checkInConversationWork(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Drain pending mailbox entries after the caller has durably injected them. */
+export declare function drainConversationMailbox(args: {
+    conversationId: string;
+    inject: (messages: InboundMessage[]) => Promise<void>;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<InboundMessage[]>;
+/** Mark selected leased mailbox entries after their session-log injection succeeds. */
+export declare function markConversationMessagesInjected(args: {
+    conversationId: string;
+    inboundMessageIds: string[];
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Mark the leased conversation as needing another queue-delivered slice. */
+export declare function requestConversationContinuation(args: {
+    conversationId: string;
+    destination: Destination;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Release the durable execution lease without changing completion state. */
+export declare function releaseConversationWork(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Finish a leased conversation and report whether runnable work remains. */
+export declare function completeConversationWork(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<"completed" | "lost_lease" | "pending">;
+/** Clear an expired durable lease so a later worker can resume safely. */
+export declare function clearExpiredConversationLease(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Remove one conversation from the active index after it is missing or idle. */
+export declare function removeActiveConversation(args: {
+    conversationId: string;
+    state?: StateAdapter;
+}): Promise<void>;
+/** List active conversation ids by oldest execution update first. */
+export declare function listActiveConversationIds(args?: {
+    limit?: number;
+    staleBeforeMs?: number;
+    state?: StateAdapter;
+}): Promise<string[]>;
+/** List retained conversations by newest visible activity first. */
+export declare function listConversationsByActivity(args?: {
+    limit?: number;
+    offset?: number;
+    state?: StateAdapter;
+}): Promise<Conversation[]>;

package/dist/chat/task-execution/store.d.ts

@@ -1,104 +1,19 @@
 import type { StateAdapter } from "chat";
-import type { Destination } from "@sentry/junior-plugin-api";
-import { type StoredSlackRequester } from "@/chat/requester";
+import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "./queue";
-export declare const CONVERSATION_BY_ACTIVITY_INDEX_KEY = "junior:conversation:by-activity";
-export declare const CONVERSATION_ACTIVE_INDEX_KEY = "junior:conversation:active";
-export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
-export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
-export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
-export type Source = "api" | "internal" | "plugin" | "scheduler" | "slack";
-export type ExecutionStatus = "awaiting_resume" | "idle" | "pending" | "running";
-export interface AgentInput {
-    attachments?: unknown[];
-    authorId?: string;
-    metadata?: Record<string, unknown>;
-    text: string;
-}
-export interface InboundMessage {
-    conversationId: string;
-    createdAtMs: number;
-    destination: Destination;
-    inboundMessageId: string;
-    injectedAtMs?: number;
-    input: AgentInput;
-    receivedAtMs: number;
-    source: Source;
-}
-export interface Lease {
-    acquiredAtMs: number;
-    expiresAtMs: number;
-    lastCheckInAtMs: number;
-    token: string;
-}
-export interface ConversationExecution {
-    inboundMessageIds: string[];
-    lastCheckpointAtMs?: number;
-    lastEnqueuedAtMs?: number;
-    lease?: Lease;
-    pendingCount: number;
-    pendingMessages: InboundMessage[];
-    runId?: string;
-    status: ExecutionStatus;
-    updatedAtMs?: number;
-}
-export interface Conversation {
-    channelName?: string;
-    conversationId: string;
-    createdAtMs: number;
-    destination?: Destination;
-    execution: ConversationExecution;
-    lastActivityAtMs: number;
-    requester?: StoredSlackRequester;
-    schemaVersion: 1;
-    source?: Source;
-    title?: string;
-    updatedAtMs: number;
-}
-export interface ConversationWorkLease {
-    acquiredAtMs: number;
-    lastCheckInAtMs: number;
-    leaseExpiresAtMs: number;
-    leaseToken: string;
-}
-export interface ConversationWorkState extends Conversation {
-    lastEnqueuedAtMs?: number;
-    lease?: ConversationWorkLease;
-    messages: InboundMessage[];
-    needsRun: boolean;
-}
-export interface StartConversationWorkAcquired {
-    leaseExpiresAtMs: number;
-    leaseToken: string;
-    status: "acquired";
-}
-export interface StartConversationWorkActive {
-    leaseExpiresAtMs: number;
-    status: "active";
-}
-export interface StartConversationWorkNoWork {
-    status: "no_work";
-}
-export type StartConversationWorkResult = StartConversationWorkAcquired | StartConversationWorkActive | StartConversationWorkNoWork;
-export interface AppendInboundMessageResult {
-    status: "appended" | "duplicate";
-}
-export interface AppendAndEnqueueInboundMessageResult extends AppendInboundMessageResult {
-    queueMessageId?: string;
-}
-export interface RequestConversationWorkResult {
-    status: "created" | "updated";
-}
+import * as workState from "./state";
+export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_STALE_ENQUEUE_MS, type AgentInput, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
+import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
 /** Return a persisted conversation record, if one exists. */
 export declare function getConversation(args: {
     conversationId: string;
     state?: StateAdapter;
-}): Promise<Conversation | undefined>;
-/** Return a persisted conversation record, if one exists. */
+}): Promise<workState.Conversation | undefined>;
+/** Return a persisted conversation work record, if one exists. */
 export declare function getConversationWorkState(args: {
     conversationId: string;
     state?: StateAdapter;
-}): Promise<ConversationWorkState | undefined>;
+}): Promise<workState.ConversationWorkState | undefined>;
 /** Count mailbox messages that have not yet reached the session log. */
 export declare function countPendingConversationMessages(conversation: Conversation): number;
 /** Return whether a conversation has pending or resumable execution work. */
@@ -106,12 +21,14 @@ export declare function hasRunnableConversationWork(conversation: Conversation):
 /** Persist one inbound message idempotently in its conversation mailbox. */
 export declare function appendInboundMessage(args: {
     message: InboundMessage;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<AppendInboundMessageResult>;
+}): Promise<workState.AppendInboundMessageResult>;
 /** Persist inbound work and send the queue nudge that wakes a worker. */
 export declare function appendAndEnqueueInboundMessage(args: {
     message: InboundMessage;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     queue: ConversationWorkQueue;
     state?: StateAdapter;
@@ -119,62 +36,58 @@ export declare function appendAndEnqueueInboundMessage(args: {
 /** Mark a conversation runnable when there is no new mailbox message. */
 export declare function requestConversationWork(args: {
     conversationId: string;
-    destination: Destination;
+    destination: InboundMessage["destination"];
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<RequestConversationWorkResult>;
+}): Promise<workState.RequestConversationWorkResult>;
 /** Record visible conversation activity without making the conversation runnable. */
-export declare function recordConversationActivity(args: {
-    activityAtMs?: number;
-    channelName?: string;
-    conversationId: string;
-    destination?: Destination;
-    nowMs?: number;
-    requester?: StoredSlackRequester;
-    source?: Source;
+export declare function recordConversationActivity(args: Parameters<ConversationStore["recordActivity"]>[0] & {
+    conversationStore?: ConversationStore;
     state?: StateAdapter;
-    title?: string;
 }): Promise<void>;
 /** Record that a wake-up nudge was accepted for the conversation. */
 export declare function markConversationWorkEnqueued(args: {
     conversationId: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<void>;
 /** Try to acquire the durable execution lease for one conversation. */
 export declare function startConversationWork(args: {
     conversationId: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<StartConversationWorkResult>;
+}): Promise<workState.StartConversationWorkResult>;
 /** Extend the durable execution lease when the worker checks in. */
 export declare function checkInConversationWork(args: {
     conversationId: string;
     leaseToken: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
 /** Drain pending mailbox entries after the caller has durably injected them. */
-export declare function drainConversationMailbox(args: {
-    conversationId: string;
-    inject: (messages: InboundMessage[]) => Promise<void>;
-    leaseToken: string;
-    nowMs?: number;
+export declare function drainConversationMailbox(args: Parameters<typeof workState.drainConversationMailbox>[0] & {
+    conversationStore?: ConversationStore;
     state?: StateAdapter;
-}): Promise<InboundMessage[]>;
+}): Promise<workState.InboundMessage[]>;
 /** Mark selected leased mailbox entries after their session-log injection succeeds. */
 export declare function markConversationMessagesInjected(args: {
     conversationId: string;
     inboundMessageIds: string[];
     leaseToken: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
 /** Mark the leased conversation as needing another queue-delivered slice. */
 export declare function requestConversationContinuation(args: {
     conversationId: string;
-    destination: Destination;
+    destination: InboundMessage["destination"];
     leaseToken: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
@@ -182,6 +95,7 @@ export declare function requestConversationContinuation(args: {
 export declare function releaseConversationWork(args: {
     conversationId: string;
     leaseToken: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
@@ -189,12 +103,14 @@ export declare function releaseConversationWork(args: {
 export declare function completeConversationWork(args: {
     conversationId: string;
     leaseToken: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<"completed" | "lost_lease" | "pending">;
+}): Promise<"pending" | "completed" | "lost_lease">;
 /** Clear an expired durable lease so a later worker can resume safely. */
 export declare function clearExpiredConversationLease(args: {
     conversationId: string;
+    conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
@@ -213,4 +129,4 @@ export declare function listActiveConversationIds(args?: {
 export declare function listConversationsByActivity(args?: {
     limit?: number;
     state?: StateAdapter;
-}): Promise<Conversation[]>;
+}): Promise<workState.Conversation[]>;

package/dist/chat/task-execution/vercel-callback.d.ts

@@ -1,10 +1,12 @@
 import type { StateAdapter } from "chat";
+import type { ConversationStore } from "@/chat/conversations/store";
 import { type ConversationWorkQueue } from "./queue";
 import { type ConversationWorkProcessResult, type ConversationWorkerResult, type ConversationWorkerContext } from "./worker";
 export declare const CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS = 30;
 export declare const CONVERSATION_WORK_DEV_CONSUMER_GROUP = "junior_conversation_work_dev";
 export interface ProcessConversationQueueMessageOptions {
     checkInIntervalMs?: number;
+    conversationStore?: ConversationStore;
     nowMs?: () => number;
     queue?: ConversationWorkQueue;
     run(context: ConversationWorkerContext): Promise<ConversationWorkerResult>;

package/dist/chat/task-execution/worker.d.ts

@@ -1,5 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
+import type { ConversationStore } from "@/chat/conversations/store";
 import { type ConversationQueueMessage, type ConversationWorkQueue } from "./queue";
 import { type InboundMessage } from "./store";
 export declare const CONVERSATION_WORK_DEFER_DELAY_MS = 15000;
@@ -20,6 +21,7 @@ export interface ConversationWorkProcessResult {
 }
 export interface ProcessConversationWorkOptions {
     checkInIntervalMs?: number;
+    conversationStore?: ConversationStore;
     nowMs?: () => number;
     queue: ConversationWorkQueue;
     run(context: ConversationWorkerContext): Promise<ConversationWorkerResult>;

package/dist/chat/tools/slack/canvas-tools.d.ts

@@ -1,6 +1,7 @@
-import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that provisions a new Slack canvas in the active channel. */
-export declare function createSlackCanvasCreateTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+export declare function createSlackCanvasCreateTool(context: SlackToolContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     title: import("@sinclair/typebox").TString;
     markdown: import("@sinclair/typebox").TString;
 }>>;

package/dist/chat/tools/slack/channel-list-messages.d.ts

@@ -1,5 +1,5 @@
-import type { ToolRuntimeContext } from "@/chat/tools/types";
-export declare function createSlackChannelListMessagesTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+export declare function createSlackChannelListMessagesTool(context: SlackToolContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
     cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     oldest: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

package/dist/chat/tools/slack/channel-post-message.d.ts

@@ -1,4 +1,5 @@
-import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
-export declare function createSlackChannelPostMessageTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+import type { ToolState } from "@/chat/tools/types";
+export declare function createSlackChannelPostMessageTool(context: SlackToolContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     text: import("@sinclair/typebox").TString;
 }>>;

package/dist/chat/tools/slack/context.d.ts

@@ -1,3 +1,16 @@
 import type { ToolRuntimeContext } from "@/chat/tools/types";
-/** Resolve the Slack channel used by first-class delivery tools. */
-export declare function getSlackDeliveryChannelId(context: ToolRuntimeContext): string | undefined;
+import type { SlackDestination } from "@sentry/junior-plugin-api";
+import type { SlackSource } from "@sentry/junior-plugin-api";
+import type { SlackRequester } from "@/chat/requester";
+export interface SlackToolContext {
+    destination?: SlackDestination;
+    source: SlackSource;
+    requester?: SlackRequester;
+    destinationChannelId?: string;
+    messageTs?: string;
+    sourceChannelId: string;
+    teamId: string;
+    threadTs?: string;
+}
+/** Resolve Slack-specific tool context from the active source/destination/requester. */
+export declare function getSlackToolContext(context: ToolRuntimeContext): SlackToolContext | undefined;

package/dist/chat/tools/slack/message-add-reaction.d.ts

@@ -1,4 +1,5 @@
-import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
-export declare function createSlackMessageAddReactionTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+import type { ToolState } from "@/chat/tools/types";
+export declare function createSlackMessageAddReactionTool(context: SlackToolContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     emoji: import("@sinclair/typebox").TString;
 }>>;

package/dist/chat/tools/slack/thread-read.d.ts

@@ -1,6 +1,6 @@
-import type { ToolRuntimeContext } from "@/chat/tools/types";
+import type { SlackToolContext } from "@/chat/tools/slack/context";
 /** Create a tool that reads a Slack thread from a shared message URL or explicit coordinates. */
-export declare function createSlackThreadReadTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+export declare function createSlackThreadReadTool(context: SlackToolContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     channel_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     ts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

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

@@ -1,12 +1,12 @@
 import type { FileUpload } from "chat";
-import type { Destination } from "@sentry/junior-plugin-api";
+import type { Destination, LocalDestination, LocalSource, SlackDestination, SlackSource, Source } from "@sentry/junior-plugin-api";
 import type { McpToolManager } from "@/chat/mcp/tool-manager";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { Skill } from "@/chat/skills";
 import type { LoadSkillMetadata } from "@/chat/tools/skill/load-skill";
 import type { AdvisorToolRuntimeContext } from "@/chat/tools/advisor/tool";
-import type { Requester } from "@/chat/requester";
+import type { LocalRequester, Requester, SlackRequester } from "@/chat/requester";
 export interface ImageGenerateToolDeps {
     fetch?: typeof fetch;
 }
@@ -34,20 +34,8 @@ export interface ToolHooks {
         webSearch?: WebSearchToolDeps;
     };
 }
-export interface ToolRuntimeContext {
+interface BaseToolRuntimeContext {
     advisor?: AdvisorToolRuntimeContext;
-    /**
-     * Raw Slack channel/conversation container for this turn: `C...`, `D...`,
-     * or `G...`. Never overridden by assistant context. Stable binding key for
-     * state scoped to a Slack conversation. Passed to plugin hooks as-is via
-     * `ToolRegistrationHookContext.channelId`.
-     */
-    channelId?: string;
-    /**
-     * Slack channel used by first-class delivery tools when assistant context
-     * points at a source channel different from the raw conversation channel.
-     */
-    deliveryChannelId?: string;
     /**
      * Opaque Junior conversation/session identity for this turn.
      * Interactive Slack turns use `slack:{channelId}:{threadTs}`.
@@ -55,18 +43,29 @@ export interface ToolRuntimeContext {
      * Do not parse as Slack unless the value starts with `slack:`.
      */
     conversationId?: string;
-    /** Runtime-owned destination for provider-neutral side effects. */
+    /** Runtime-owned default outbound destination, if this invocation has one. */
     destination?: Destination;
     requester?: Requester;
-    teamId?: string;
-    messageTs?: string;
-    threadTs?: string;
+    /** Runtime-owned source where this invocation came from. */
+    source: Source;
     userText?: string;
     artifactState?: ThreadArtifactsState;
     configuration?: Record<string, unknown>;
     mcpToolManager?: McpToolManager;
     sandbox: SandboxWorkspace;
 }
+interface SlackToolRuntimeContext extends BaseToolRuntimeContext {
+    destination?: SlackDestination;
+    requester?: SlackRequester;
+    source: SlackSource;
+}
+interface LocalToolRuntimeContext extends BaseToolRuntimeContext {
+    destination?: LocalDestination;
+    requester?: LocalRequester;
+    source: LocalSource;
+    slack?: never;
+}
+export type ToolRuntimeContext = LocalToolRuntimeContext | SlackToolRuntimeContext;
 export interface ToolState {
     artifactState: ThreadArtifactsState;
     patchArtifactState: (patch: Partial<ThreadArtifactsState>) => void | Promise<void>;
@@ -74,3 +73,4 @@ export interface ToolState {
     getOperationResult: <T>(operationKey: string) => T | undefined;
     setOperationResult: (operationKey: string, result: unknown) => void;
 }
+export {};