@sentry/junior 0.181.1 → 0.183.0

package/dist/{catalog-runtime-CJTFLCK3.js → catalog-runtime-3I3JOIIH.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-DXK3VTVP.js";
-import "./chunk-7UF37LNL.js";
+} from "./chunk-E3OBGRHN.js";
+import "./chunk-EENQGEIP.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-2CZ63QCL.js";
+import "./chunk-LZBPGX5A.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-S5X2VQOD.js";
+import "./chunk-W46NIB5H.js";
 export {
   pluginCatalogRuntime
 };

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

@@ -40,5 +40,7 @@ export declare function completeAgentInvocation(args: {
     status: "blocked" | "failed";
     nowMs?: number;
 }): Promise<AgentInvocation | undefined>;
-/** Return whether an invocation already owns its immutable terminal result. */
-export declare function isTerminalAgentInvocation(invocation: AgentInvocation): boolean;
+/** Return whether an agent invocation has finished. */
+export declare function isTerminalAgentInvocation(invocation: AgentInvocation): invocation is Extract<AgentInvocation, {
+    status: "blocked" | "completed" | "failed";
+}>;

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

@@ -20,9 +20,7 @@ export declare function createAndEnqueueAgentInvocation(input: CreateAgentInvoca
 /** Resolve invocation execution from mailbox input or durable active state. */
 export declare function resolveAgentInvocationId(context: ConversationWorkerContext): Promise<string | undefined>;
 /** Build the invocation consumer that advances work through the shared runner. */
-export declare function createAgentInvocationWorker(options: {
-    agentRunner: AgentRunner;
-}): (context: ConversationWorkerContext, invocationId: string) => Promise<ConversationWorkerResult>;
+export declare function createAgentInvocationWorker(agentRunner: AgentRunner): (context: ConversationWorkerContext, invocationId: string) => Promise<ConversationWorkerResult>;
 /** Route invocation-backed work before falling through to existing consumers. */
 export declare function routeAgentInvocationWork(options: {
     fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;

package/dist/chat/api-turns/adapter-conversations.d.ts

@@ -0,0 +1,15 @@
+/** Bind app adapters to Junior's Conversation runtime. */
+import type { StateAdapter } from "chat";
+import type { AdapterConversations } from "@/app-adapter";
+import type { ConversationEventStore } from "@/chat/conversations/history";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+interface AdapterConversationOptions {
+    conversationStore?: ConversationStore;
+    eventStore: ConversationEventStore;
+    queue: ConversationWorkQueue;
+    state: StateAdapter;
+}
+/** Create the Conversation capability supplied to app adapters. */
+export declare function createAdapterConversations(options: AdapterConversationOptions): AdapterConversations;
+export {};

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

@@ -0,0 +1,12 @@
+import type { StateAdapter } from "chat";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import { type StopConversationWorkResult } from "@/chat/task-execution/store";
+/** Stop the current API Turn and wake an idle durable resume when needed. */
+export declare function stopApiConversationTurn(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}): Promise<StopConversationWorkResult>;

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

@@ -37,6 +37,11 @@ export interface ApiConversationMessageAccepted {
     messageId: string;
     status: "accepted" | "duplicate";
 }
+export type ApiConversationMessageAdmission = ApiConversationMessageAccepted | {
+    conversationId: string;
+    messageId: string;
+    status: "active";
+};
 /**
  * Build a durable API conversation id for one viewer + create key.
  *
@@ -81,7 +86,10 @@ 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 to an existing conversation and wake the worker. */
+/** Append one 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: {

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

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

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

@@ -1,6 +1,6 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import type { Message } from "chat";
-import { type AssistantLifecycleEvent } from "@/chat/runtime/slack-runtime";
+import { type AssistantLifecycleEvent } from "@/chat/providers/slack/runtime";
 import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
 export interface CreateSlackRuntimeOptions {
     getSlackAdapter: () => SlackAdapter;
@@ -14,6 +14,6 @@ export declare function createSlackRuntime(options: CreateSlackRuntimeOptions):
     }) => 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>;
+    handleNewMention: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/providers/slack/runtime").SlackTurnOptions) => Promise<void>;
+    handleSubscribedMessage: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/providers/slack/runtime").SlackTurnOptions) => Promise<void>;
 };

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

@@ -2,19 +2,19 @@ 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 { ReplyExecutorServices } from "@/chat/runtime/reply-executor";
+import type { SlackTurnServices } from "@/chat/providers/slack/turn";
 import { type VisionContextDeps, type VisionContextService } from "@/chat/slack/vision-context";
 export interface JuniorRuntimeServices {
     conversationMemory: ConversationMemoryService;
     contextCompactor: ContextCompactor;
-    replyExecutor: ReplyExecutorServices;
+    replyExecutor: SlackTurnServices;
     subscribedReplyPolicy: SubscribedReplyPolicy;
     visionContext: VisionContextService;
 }
 export interface JuniorRuntimeServiceOverrides {
     conversationMemory?: Partial<ConversationMemoryDeps>;
     contextCompactor?: Partial<ContextCompactorDeps>;
-    replyExecutor?: Partial<ReplyExecutorServices>;
+    replyExecutor?: Partial<SlackTurnServices>;
     subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
     sandbox?: {
         tracePropagation?: SandboxEgressTracePropagationConfig;

package/dist/chat/code/publisher.d.ts

@@ -0,0 +1,3 @@
+import type { CodeChangePublisher } from "@sentry/junior-plugin-api";
+/** Connect a plugin to Junior's code records. */
+export declare function createCodeChangePublisher(provider: string): CodeChangePublisher;

package/dist/chat/code/store.d.ts

@@ -0,0 +1,9 @@
+import { type CodeChangeInput } from "@sentry/junior-plugin-api";
+import type { JuniorDatabase } from "@/db/db";
+/** Record the latest details for one code change created by Junior. */
+export declare function recordCodeChange(db: JuniorDatabase, provider: string, input: CodeChangeInput): Promise<void>;
+/** Add conversation links to an existing code change. */
+export declare function associateCodeChangeConversations(db: JuniorDatabase, provider: string, input: {
+    conversationIds: string[];
+    providerId: string;
+}): Promise<void>;

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

@@ -17,5 +17,15 @@ export declare function eventTaskBelongsToUser(task: EventTask, user: User): boo
 export declare function listEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<EventTask[]>;
 /** List event tasks whose current Slack destination is public. */
 export declare function listPublicEventTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<EventTask[]>;
+/**
+ * Collect match keys from event tasks for these identifiers and event types.
+ * Does not evaluate match values — only reports keys that filters use.
+ */
+export declare function collectEventTaskMatchKeys(db: JuniorDatabase, input: {
+    eventTypes: string[];
+    identifiers: string[];
+    namespace: string;
+    teamId: string;
+}): Promise<string[]>;
 /** Find every task matching one normalized resource event. */
 export declare function findMatchingEventTasks(db: JuniorDatabase, event: ResourceEvent, teamId: string): Promise<EventTask[]>;

package/dist/chat/event-tasks/tool-support.d.ts

@@ -19,6 +19,7 @@ export declare const eventTaskToolResultSchema: z.ZodObject<{
         resourceType: z.ZodString;
         label: z.ZodString;
         events: z.ZodArray<z.ZodString>;
+        match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         credentialMode: z.ZodEnum<{
             system: "system";
             creator: "creator";
@@ -47,6 +48,7 @@ export declare const eventTaskListToolResultSchema: z.ZodObject<{
         resourceType: z.ZodString;
         label: z.ZodString;
         events: z.ZodArray<z.ZodString>;
+        match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         credentialMode: z.ZodEnum<{
             system: "system";
             creator: "creator";
@@ -73,13 +75,15 @@ export declare function registeredEventTaskTriggerSchema(catalog: ResourceEventC
     events: z.ZodArray<z.ZodString | z.ZodEnum<{
         [x: string]: string;
     }>>;
+    match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>]>>>;
 }, z.core.$strict>;
 /** Reject an event-task trigger that is no longer supported by the catalog. */
 export declare function requireSupportedEventTaskTrigger(catalog: ResourceEventCatalog, trigger: {
     events: string[];
+    match?: EventTask["trigger"]["match"];
     namespace: string;
     resourceType: string;
-}): void;
+}): EventTask["trigger"]["match"] | undefined;
 /** Require the active Slack authority used for event-task management. */
 export declare function requireEventTaskSlackContext(context: ToolRuntimeContext): {
     actor: import("../actor").SlackActor;
@@ -121,6 +125,7 @@ export declare function compactEventTask(task: EventTask, catalog: ResourceEvent
         userName?: string | undefined;
     };
     triggerAvailable: boolean;
+    match?: Record<string, unknown> | undefined;
 };
 /** Return the standard successful event-task tool result. */
 export declare function eventTaskSuccess(task: EventTask, catalog: ResourceEventCatalog): {
@@ -139,5 +144,6 @@ export declare function eventTaskSuccess(task: EventTask, catalog: ResourceEvent
             userName?: string | undefined;
         };
         triggerAvailable: boolean;
+        match?: Record<string, unknown> | undefined;
     };
 };

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

@@ -35,6 +35,7 @@ export declare const eventTaskSchema: z.ZodObject<{
     trigger: z.ZodObject<{
         events: z.ZodArray<z.ZodString>;
         label: z.ZodString;
+        match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>]>>>;
         namespace: z.ZodString;
         identifier: z.ZodString;
         resourceType: z.ZodString;

package/dist/chat/experimental.d.ts

@@ -3,7 +3,7 @@
  * Add new keys here as features graduate from private experiments; remove them
  * once they become stable defaults.
  */
-export declare const EXPERIMENTAL_FEATURES: readonly ["acp", "subagents"];
+export declare const EXPERIMENTAL_FEATURES: readonly ["passive-routing", "subagents"];
 /** One known experimental feature name. */
 export type ExperimentalFeature = (typeof EXPERIMENTAL_FEATURES)[number];
 /** App-level opt-ins for unstable product features. */

package/dist/chat/ingress/slack-webhook.d.ts

@@ -1,6 +1,6 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { type StateAdapter } from "chat";
-import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { SlackTurnRuntime } from "@/chat/providers/slack/runtime";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";

package/dist/chat/plugins/agent-hooks.d.ts

@@ -61,6 +61,11 @@ export declare function getPluginTools(context: ToolRuntimeContext, sandbox?: Pl
 /** Collect route handlers exposed by plugins for app-level mounting. */
 export declare function getPluginRoutes(options: {
     resourceEvents: {
+        neededMatchKeys?(input: {
+            eventTypes: string[];
+            identifiers: string[];
+            namespace: string;
+        }): Promise<string[]>;
         publish(event: ResourceEvent): Promise<void>;
     };
 }): PluginRouteRegistration[];

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

@@ -1,5 +1,5 @@
 /**
- * Slack event runtime.
+ * Slack provider runtime.
  *
  * This module owns inbound Slack routing decisions for mentions, subscribed
  * messages, assistant lifecycle events, and retryable turn pauses. It should
@@ -93,7 +93,7 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         thread: Thread;
     }) => Promise<void>;
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<TPreparedState>;
-    replyToThread: (thread: Thread, message: Message, options: {
+    executeSlackTurn: (thread: Thread, message: Message, options: {
         beforeFirstResponsePost?: () => Promise<void>;
         conversationId?: string;
         destination: Destination;

package/dist/chat/{runtime/reply-executor.d.ts → providers/slack/turn.d.ts}

@@ -1,10 +1,10 @@
 /**
- * Slack reply execution boundary.
+ * Add Slack provider behavior around one native agent Turn.
  *
- * This module bridges prepared Slack thread state into the agent runner
- * and commits the resulting Slack-visible delivery/state updates. It is where
- * queued messages, compaction, status updates, and Slack posting meet; agent
- * internals stay behind the runner seam.
+ * 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`.
  */
 import type { Message, Thread } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
@@ -17,7 +17,7 @@ import { lookupSlackUser } from "@/chat/slack/user";
 import type { PausedTurnRequest } from "@/chat/task-execution/turn-wake";
 import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
-export interface ReplyExecutorServices {
+export interface SlackTurnServices {
     agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
     getPausedTurnRequest: (args: {
@@ -32,7 +32,7 @@ export interface ReplyExecutorServices {
         sessionId: string;
     }) => Promise<void>;
 }
-interface ReplyExecutorDeps {
+interface SlackTurnDeps {
     getSlackAdapter: () => SlackAdapter;
     resolveUserAttachments: (attachments: Message["attachments"] | undefined, context: {
         threadId?: string;
@@ -48,9 +48,10 @@ interface ReplyExecutorDeps {
         promptText?: string;
     }>>;
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;
-    services: ReplyExecutorServices;
+    services: SlackTurnServices;
 }
-export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options: {
+/** Build the Slack caller that prepares input and delivers output for a Turn. */
+export declare function createSlackTurn(deps: SlackTurnDeps): (thread: Thread, message: Message, options: {
     beforeFirstResponsePost?: () => Promise<void>;
     conversationId?: string;
     destination: Destination;

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

@@ -1,4 +1,4 @@
-import { type PluginResourceEvents } from "@sentry/junior-plugin-api";
+import { type PluginResourceEvents, type ResourceEventMatch, type ResourceEventMatchFields } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 type ResourceEventRegistration = Pick<PluginResourceEvents, "resourceTypes" | "normalizeIdentifier">;
 export type ResourceEventCatalog = Readonly<Record<string, ResourceEventRegistration>>;
@@ -18,6 +18,16 @@ export declare function registeredResourceTypeSchema(catalog: ResourceEventCatal
 export declare function pluginSupportsEvent(catalog: ResourceEventCatalog, namespace: string, resourceType: string, eventType: string): boolean;
 /** Return app guidance for one registered resource type and event type. */
 export declare function resourceEventGuidance(catalog: ResourceEventCatalog, namespace: string, resourceType: string, eventType: string): string | undefined;
+/** Return declared match keys for one registered resource type. */
+export declare function resourceEventMatchFields(catalog: ResourceEventCatalog, namespace: string, resourceType: string): ResourceEventMatchFields | undefined;
+/** Build the match object the tools accept for one resource type. */
+export declare function registeredResourceEventMatchSchema(): z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>]>>>;
+/** Reject match keys the resource type does not list. */
+export declare function requireSupportedResourceEventMatch(catalog: ResourceEventCatalog, input: {
+    match?: ResourceEventMatch;
+    namespace: string;
+    resourceType: string;
+}): ResourceEventMatch | undefined;
 /** Normalize one selector with the convention declared by its plugin. */
 export declare function normalizeEventIdentifier(catalog: ResourceEventCatalog, namespace: string, identifier: string): string;
 export {};

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

@@ -1,5 +1,5 @@
 import type { StateAdapter } from "chat";
-import { type Destination } from "@sentry/junior-plugin-api";
+import { type Destination, type ResourceEventData, type ResourceEventMatch } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 declare const subscriptionSchema: z.ZodObject<{
     conversationId: z.ZodString;
@@ -17,6 +17,7 @@ declare const subscriptionSchema: z.ZodObject<{
     id: z.ZodString;
     intent: z.ZodString;
     label: z.ZodString;
+    match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>]>>>;
     namespace: z.ZodString;
     identifier: z.ZodString;
     resourceType: z.ZodString;
@@ -35,6 +36,7 @@ export interface CreateResourceEventSubscriptionInput {
     expiresAtMs: number;
     intent: string;
     label: string;
+    match?: ResourceEventMatch;
     namespace: string;
     identifier: string;
     resourceType: string;
@@ -63,8 +65,21 @@ export declare function cancelSubscriptions(input: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<void>;
+/**
+ * Collect match keys from active watches for these identifiers and event types.
+ * Does not evaluate match values — only reports keys that filters use.
+ */
+export declare function collectResourceEventMatchKeys(input: {
+    eventTypes: string[];
+    identifiers: string[];
+    namespace: string;
+    nowMs?: number;
+    state?: StateAdapter;
+    teamId: string;
+}): Promise<string[]>;
 /** Find active subscriptions interested in a normalized resource event. */
 export declare function findMatchingResourceEventSubscriptions(input: {
+    data?: ResourceEventData;
     eventType: string;
     nowMs?: number;
     namespace: string;
@@ -74,6 +89,7 @@ export declare function findMatchingResourceEventSubscriptions(input: {
 }): Promise<ResourceEventSubscription[]>;
 /** Recheck and deliver a matched subscription while holding its status lock. */
 export declare function deliverResourceEventSubscription(input: {
+    data?: ResourceEventData;
     deliver: (subscription: ResourceEventSubscription) => Promise<boolean>;
     eventType: string;
     nowMs?: number;

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

@@ -0,0 +1,30 @@
+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 { AgentRunResult } from "@/chat/services/turn-result";
+type SavedTurnResult = {
+    finishedAtMs?: number;
+    outcome: CompleteConversationTurnInput["outcome"];
+} | {
+    finishedAtMs?: number;
+    failureCode: FailConversationTurnInput["failureCode"];
+    outcome: "failed";
+};
+type TurnExecutionOutcome = Exclude<AgentRunOutcome, {
+    status: "completed";
+}> | {
+    status: "completed";
+};
+/** An error thrown while the agent advances a Run. */
+export declare class AgentRunError extends Error {
+    constructor(cause: unknown);
+}
+/**
+ * Run the agent and finish the Turn after the caller saves its result.
+ *
+ * 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.
+ */
+export declare function executeTurn(agentRunner: AgentRunner, run: AgentRun, saveResult: (result: AgentRunResult) => Promise<SavedTurnResult>): Promise<TurnExecutionOutcome>;
+export {};

package/dist/chat/services/subscribed-decision.d.ts

@@ -8,7 +8,8 @@ export declare enum SubscribedReplyReason {
     Classifier = "llm_classifier",
     SideConversation = "side_conversation",
     LowConfidence = "low_confidence",
-    ClassifierError = "classifier_error"
+    ClassifierError = "classifier_error",
+    PassiveDisabled = "passive_disabled"
 }
 export interface SubscribedDecisionInput {
     rawText: string;

package/dist/chat/slack/dispatch-turn.d.ts

@@ -2,24 +2,22 @@ import { Message, ThreadImpl } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
 import type { DispatchRecord } from "@/chat/agent-dispatch/types";
-interface DispatchReplyToThread {
-    (thread: ThreadImpl, message: Message, options: {
-        ack?: () => Promise<void>;
-        conversationId?: string;
-        destination: DispatchRecord["destination"];
-        execution: DispatchTurnContext;
-        publishExternally?: boolean;
-        onTurnDeliveryAccepted?: (messageId?: string) => void;
-        onTurnOutcome?: (result: DispatchTurnResult) => void;
-        shouldYield?: () => boolean;
-        skipBackfill?: boolean;
-    }): Promise<void>;
-}
+type ExecuteSlackTurn = (thread: ThreadImpl, message: Message, options: {
+    ack?: () => Promise<void>;
+    conversationId?: string;
+    destination: DispatchRecord["destination"];
+    execution: DispatchTurnContext;
+    publishExternally?: boolean;
+    onTurnDeliveryAccepted?: (messageId?: string) => void;
+    onTurnOutcome?: (result: DispatchTurnResult) => void;
+    shouldYield?: () => boolean;
+    skipBackfill?: boolean;
+}) => Promise<void>;
 /** Build the Slack provider adapter for agent-dispatched conversation turns. */
 export declare function createSlackDispatchTurnRunner(options: {
     getLocationConfiguration: (destination: DispatchRecord["destination"]) => DispatchTurnContext["locationConfiguration"];
     getSlackAdapter: () => SlackAdapter;
-    replyToThread: DispatchReplyToThread;
+    executeSlackTurn: ExecuteSlackTurn;
 }): (dispatch: DispatchRecord, hooks: {
     ack: () => Promise<void>;
     shouldYield?: () => boolean;

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

@@ -1,7 +1,7 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { Message, ThreadImpl, type StateAdapter } from "chat";
 import { z } from "zod";
-import type { SlackTurnOptions } from "@/chat/runtime/slack-runtime";
+import type { SlackTurnOptions } from "@/chat/providers/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";

package/dist/chat/tools/create-event-task.d.ts

@@ -12,6 +12,7 @@ export declare function createEventTaskTool(context: ToolRuntimeContext, catalog
             resourceType: string;
             label: string;
             events: string[];
+            match?: Record<string, string | number | boolean | (string | number)[]> | undefined;
         };
         title?: string | null | undefined;
         credentialMode?: "system" | "creator" | null | undefined;
@@ -32,6 +33,7 @@ export declare function createEventTaskTool(context: ToolRuntimeContext, catalog
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         };
         target?: string | undefined;
         truncated?: boolean | undefined;
@@ -56,6 +58,7 @@ export declare function createEventTaskTool(context: ToolRuntimeContext, catalog
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         };
         target?: string | undefined;
         truncated?: boolean | undefined;

package/dist/chat/tools/delete-event-task.d.ts

@@ -23,6 +23,7 @@ export declare function createDeleteEventTaskTool(context: ToolRuntimeContext, c
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         };
         target?: string | undefined;
         truncated?: boolean | undefined;
@@ -47,6 +48,7 @@ export declare function createDeleteEventTaskTool(context: ToolRuntimeContext, c
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         };
         target?: string | undefined;
         truncated?: boolean | undefined;

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

@@ -21,6 +21,7 @@ export declare function createListEventTasksTool(context: ToolRuntimeContext, ca
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         }[];
         truncated: boolean;
         target?: string | undefined;
@@ -45,6 +46,7 @@ export declare function createListEventTasksTool(context: ToolRuntimeContext, ca
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         }[];
         truncated: boolean;
         target?: string | undefined;

package/dist/chat/tools/list-resource-event-subscriptions.d.ts

@@ -14,6 +14,7 @@ export declare function createListResourceEventSubscriptionsTool(context: ToolRu
             events: string[];
             intent: string;
             expiresAtMs: number;
+            match?: Record<string, unknown> | undefined;
         }[];
         target?: string | undefined;
         truncated?: boolean | undefined;
@@ -32,6 +33,7 @@ export declare function createListResourceEventSubscriptionsTool(context: ToolRu
             events: string[];
             intent: string;
             expiresAtMs: number;
+            match?: Record<string, unknown> | undefined;
         }[];
         target?: string | undefined;
         truncated?: boolean | undefined;

package/dist/chat/tools/search-resource-event-types.d.ts

@@ -17,6 +17,11 @@ export declare function createSearchResourceEventTypesTool(catalog: ResourceEven
             type: string;
             supportedEvents: string[];
             suggestedEvents?: string[] | undefined;
+            matchFields?: Record<string, {
+                kind: "string" | "number" | "boolean";
+                description: string;
+                enum?: string[] | undefined;
+            }> | undefined;
         }[];
         target?: string | undefined;
         truncated?: boolean | undefined;
@@ -34,6 +39,11 @@ export declare function createSearchResourceEventTypesTool(catalog: ResourceEven
             type: string;
             supportedEvents: string[];
             suggestedEvents?: string[] | undefined;
+            matchFields?: Record<string, {
+                kind: "string" | "number" | "boolean";
+                description: string;
+                enum?: string[] | undefined;
+            }> | undefined;
         }[];
         target?: string | undefined;
         truncated?: boolean | undefined;

package/dist/chat/tools/update-event-task.d.ts

@@ -13,6 +13,7 @@ export declare function createUpdateEventTaskTool(context: ToolRuntimeContext, c
             resourceType: string;
             label: string;
             events: string[];
+            match?: Record<string, string | number | boolean | (string | number)[]> | undefined;
         } | null | undefined;
         credentialMode?: "system" | "creator" | null | undefined;
     };
@@ -32,6 +33,7 @@ export declare function createUpdateEventTaskTool(context: ToolRuntimeContext, c
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         };
         target?: string | undefined;
         truncated?: boolean | undefined;
@@ -56,6 +58,7 @@ export declare function createUpdateEventTaskTool(context: ToolRuntimeContext, c
                 userName?: string | undefined;
             };
             triggerAvailable: boolean;
+            match?: Record<string, unknown> | undefined;
         };
         target?: string | undefined;
         truncated?: boolean | undefined;