@sentry/junior 0.81.0 → 0.83.0

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

@@ -1,5 +1,5 @@
 import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
-import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import { scheduleSessionCompletedPluginTasks } from "@/chat/plugins/task-runner";
 import { scheduleDispatchCallback } from "./signing";
 import type { DispatchCallback } from "./types";

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

@@ -1,5 +1,5 @@
 import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
-import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 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";

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

@@ -1,6 +1,6 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { StoredSlackRequester } from "@/chat/requester";
-export type ConversationSource = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+export type ConversationSource = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
 export type ConversationStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
 export interface ConversationExecution {
     lastCheckpointAtMs?: number;

package/dist/chat/egress/credentialed.d.ts

@@ -0,0 +1,57 @@
+import { type SandboxEgressGrantSelection } from "@/chat/sandbox/egress/credentials";
+import { type SandboxEgressCredentialContext, type SandboxEgressCredentialLease } from "@/chat/sandbox/egress/session";
+import { type SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+/**
+ * Intercepts the already-authenticated provider request before live forwarding.
+ *
+ * Tests use this to inspect the exact upstream request after grant selection
+ * and credential header injection, without weakening the proxy verification
+ * path that runs before this hook is reached.
+ */
+export type CredentialedEgressHttpInterceptor = (input: {
+    provider: string;
+    request: Request;
+    upstreamUrl: URL;
+}) => Promise<Response | undefined>;
+/** Runtime dependencies for the credentialed provider forwarding step. */
+export interface CredentialedEgressDeps {
+    clearCredentialLease?: (provider: string, grantName: string, credentialContext: SandboxEgressCredentialContext) => Promise<void>;
+    fetch?: typeof fetch;
+    issueCredentialLease?: (provider: string, selection: SandboxEgressGrantSelection, credentialContext: SandboxEgressCredentialContext) => Promise<SandboxEgressCredentialLease>;
+    interceptHttp?: CredentialedEgressHttpInterceptor;
+    recordAuthRequired?: (input: {
+        authorization?: SandboxEgressCredentialLease["authorization"];
+        credentialContext: SandboxEgressCredentialContext;
+        grant: SandboxEgressCredentialLease["grant"];
+        kind?: "auth_required" | "unavailable";
+        message: string;
+        provider: string;
+    }) => Promise<void>;
+    recordPermissionDenied?: (input: {
+        credentialContext: SandboxEgressCredentialContext;
+        lease: SandboxEgressCredentialLease;
+        message: string;
+        provider: string;
+        upstream: Response;
+        upstreamUrl: URL;
+    }) => Promise<void>;
+    tracePropagation?: SandboxEgressTracePropagationConfig;
+}
+/**
+ * Forward one verified sandbox egress request with host-managed credentials.
+ *
+ * The caller must already have authenticated the sandbox VM, checked the signed
+ * credential context, and resolved the provider for `upstreamUrl`. This function
+ * then selects the read/write grant, issues or reuses a short-lived credential
+ * lease, applies its header transforms, and maps provider auth failures into
+ * command-level signals instead of throwing raw upstream details at the agent.
+ */
+export declare function executeCredentialedEgressRequest(input: {
+    activeEgressId: string;
+    credentialContext: SandboxEgressCredentialContext;
+    deps: CredentialedEgressDeps;
+    operation?: string;
+    provider: string;
+    request: Request;
+    upstreamUrl: URL;
+}): Promise<Response>;

package/dist/chat/egress/plugin.d.ts

@@ -0,0 +1,24 @@
+import type { PluginAuthorization, PluginEgress } from "@sentry/junior-plugin-api";
+import type { CredentialContext } from "@/chat/credentials/context";
+interface PluginEgressAuth {
+    handleAuthRequired(input: {
+        authorization?: PluginAuthorization;
+        grant: {
+            access: "read" | "write";
+            name: string;
+            reason?: string;
+            requirements?: string[];
+        };
+        kind: "auth_required" | "unavailable";
+        message: string;
+        provider: string;
+    }): Promise<void>;
+}
+interface PluginEgressDeps {
+    credentialContext?: CredentialContext;
+    fetch?: typeof fetch;
+    pluginAuth: PluginEgressAuth;
+}
+/** Create host-owned provider egress for plugin runtime tools. */
+export declare function createPluginEgress(deps: PluginEgressDeps): PluginEgress;
+export {};

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

@@ -19,7 +19,7 @@ export interface ToolHookResult {
 export interface PluginRouteRegistration extends PluginRoute {
     pluginName: string;
 }
-export interface PluginDashboardRouteRegistration {
+export interface PluginApiRouteRegistration {
     app: PluginRouteApp;
     pluginName: string;
 }
@@ -43,8 +43,8 @@ export declare function getPluginUserPromptContributions(args: {
 export declare function getPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
 /** Collect route handlers exposed by plugins for app-level mounting. */
 export declare function getPluginRoutes(): PluginRouteRegistration[];
-/** Collect dashboard-scoped route apps exposed by plugins. */
-export declare function getPluginDashboardRoutes(): PluginDashboardRouteRegistration[];
+/** Collect authenticated product API route apps exposed by plugins. */
+export declare function getPluginApiRoutes(): PluginApiRouteRegistration[];
 /** Resolve the first plugin conversation URL for finalized Slack footers. */
 export declare function getPluginSlackConversationLink(conversationId: string): SlackConversationLink | undefined;
 /** Collect read-only operational summaries exposed by plugins. */

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

@@ -3,6 +3,7 @@ import type { StoredTokens, UserTokenStore } from "@/chat/credentials/user-token
 export interface EgressGrantInput {
     bodyText?: string;
     method: string;
+    operation?: string;
     provider: string;
     upstreamUrl: URL;
 }
@@ -11,6 +12,7 @@ export declare function selectPluginGrant(input: EgressGrantInput): Promise<Plug
 export interface EgressResponseInput {
     grant: PluginGrant;
     method: string;
+    operation?: string;
     provider: string;
     response: {
         headers: Headers;

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

@@ -0,0 +1,23 @@
+import type { StateAdapter } from "chat";
+import { z } from "zod";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+declare const ingestResourceEventInputSchema: z.ZodObject<{
+    eventKey: z.ZodString;
+    eventType: z.ZodString;
+    occurredAtMs: z.ZodNumber;
+    provider: z.ZodString;
+    resourceRef: z.ZodString;
+    terminal: z.ZodOptional<z.ZodBoolean>;
+    trustedSummary: z.ZodString;
+    untrustedText: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type IngestResourceEventInput = z.output<typeof ingestResourceEventInputSchema>;
+/** Match a normalized provider event and enqueue notifications into conversations. */
+export declare function ingestResourceEvent(input: unknown, options: {
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}): Promise<{
+    enqueued: number;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import { appendAndEnqueueInboundMessage } from "@/chat/task-execution/store";
+import type { ResourceEventSubscription } from "@/chat/resource-events/store";
+export interface ResourceEventNotification {
+    eventKey: string;
+    eventType: string;
+    occurredAtMs: number;
+    provider: string;
+    resourceRef: string;
+    terminal?: boolean;
+    trustedSummary: string;
+    untrustedText?: string;
+}
+/** Enqueue a resource event as normal conversation mailbox input. */
+export declare function enqueueResourceEventNotification(args: {
+    event: ResourceEventNotification;
+    queue: ConversationWorkQueue;
+    subscription: ResourceEventSubscription;
+    state?: Parameters<typeof appendAndEnqueueInboundMessage>[0]["state"];
+}): Promise<Awaited<ReturnType<typeof appendAndEnqueueInboundMessage>>>;

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

@@ -0,0 +1,79 @@
+import type { StateAdapter } from "chat";
+import { type Destination } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+declare const subscriptionSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    events: z.ZodArray<z.ZodString>;
+    expiresAtMs: z.ZodNumber;
+    id: z.ZodString;
+    intent: z.ZodString;
+    label: z.ZodString;
+    provider: z.ZodString;
+    resourceRef: z.ZodString;
+    resourceType: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        cancelled: "cancelled";
+    }>;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+export type ResourceEventSubscription = z.output<typeof subscriptionSchema>;
+export interface CreateResourceEventSubscriptionInput {
+    conversationId: string;
+    destination: Destination;
+    events: string[];
+    expiresAtMs: number;
+    intent: string;
+    label: string;
+    provider: string;
+    resourceRef: string;
+    resourceType: string;
+}
+/** Create or replace the active subscription for one conversation/resource/event set. */
+export declare function createResourceEventSubscription(input: CreateResourceEventSubscriptionInput, options?: {
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription>;
+/** List active subscriptions bound to one conversation. */
+export declare function listResourceEventSubscriptions(input: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription[]>;
+/** Cancel a current-conversation subscription and remove it from match indexes. */
+export declare function cancelResourceEventSubscription(input: {
+    conversationId: string;
+    id: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription | undefined>;
+/** Find active subscriptions interested in a normalized provider event. */
+export declare function findMatchingResourceEventSubscriptions(input: {
+    eventType: string;
+    nowMs?: number;
+    provider: string;
+    resourceRef: string;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription[]>;
+/** Recheck and deliver a matched subscription while holding its status lock. */
+export declare function deliverResourceEventSubscription(input: {
+    deliver: (subscription: ResourceEventSubscription) => Promise<boolean>;
+    eventType: string;
+    nowMs?: number;
+    provider: string;
+    resourceRef: string;
+    state?: StateAdapter;
+    subscription: ResourceEventSubscription;
+    terminal?: boolean;
+}): Promise<boolean>;
+export {};

package/dist/chat/respond.d.ts

@@ -5,7 +5,7 @@ import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { ImageGenerateToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
 import type { PiMessage } from "@/chat/pi/messages";
 import { type SandboxAcquiredState } from "@/chat/sandbox/sandbox";
-import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import { type ToolExecutionReport } from "@/chat/tools/agent-tools";

package/dist/chat/sandbox/{egress-credentials.d.ts → egress/credentials.d.ts}

@@ -1,5 +1,6 @@
 import type { PluginAuthorization, PluginGrant } from "@sentry/junior-plugin-api";
-import { type SandboxEgressCredentialContext, type SandboxEgressCredentialLease } from "@/chat/sandbox/egress-session";
+import { type SandboxEgressCredentialContext, type SandboxEgressCredentialLease } from "@/chat/sandbox/egress/session";
+/** Describes whether grant selection came from plugin hooks or the broker default. */
 export type SandboxEgressGrantSelection = {
     grant: PluginGrant;
     source: "plugin";
@@ -8,7 +9,12 @@ export type SandboxEgressGrantSelection = {
     source: "broker";
 };
 export type SandboxEgressCredentialErrorKind = "auth_required" | "unavailable";
-/** Signals that egress selected a grant but could not issue credential headers. */
+/**
+ * Signals that egress selected a grant but could not issue credential headers.
+ *
+ * Callers convert this into command-level auth-required state so the agent can
+ * request authorization without exposing provider-specific lease internals.
+ */
 export declare class SandboxEgressCredentialError extends Error {
     readonly authorization?: PluginAuthorization;
     readonly grant: PluginGrant;
@@ -22,16 +28,33 @@ export declare class SandboxEgressCredentialError extends Error {
         provider: string;
     });
 }
-/** Select the plugin-defined or default grant needed for one outbound request. */
+/**
+ * Select the grant needed for one outbound request.
+ *
+ * GitHub GraphQL and other plugin-owned APIs may need body-aware grant choices;
+ * providers without hooks use a simple read/write default based on HTTP method.
+ */
 export declare function selectSandboxEgressGrant(input: {
     bodyText?: string;
     method: string;
+    operation?: string;
     provider: string;
     upstreamUrl: URL;
 }): Promise<SandboxEgressGrantSelection>;
-/** Resolve the authorization flow attached to a broker-selected egress grant. */
+/**
+ * Resolve the authorization flow attached to a broker-selected egress grant.
+ *
+ * Plugin-selected grants can return their own authorization metadata when
+ * issuing credentials; broker defaults use the provider OAuth config.
+ */
 export declare function authorizationForSandboxEgressGrant(provider: string, selection: SandboxEgressGrantSelection): PluginAuthorization | undefined;
-/** Return a cached or newly issued credential lease for a selected grant. */
+/**
+ * Return cached or newly issued credential header transforms for a selected grant.
+ *
+ * Leases are cached per actor/context/grant, validated against provider-owned
+ * domains, and reused only while both the provider lease and sandbox context are
+ * still valid.
+ */
 export declare function sandboxEgressCredentialLease(provider: string, selection: SandboxEgressGrantSelection, context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease>;
 /** Return whether a credential lease can modify requests to the target host. */
 export declare function hasSandboxEgressLeaseTransformForHost(lease: SandboxEgressCredentialLease, host: string): boolean;

package/dist/chat/sandbox/egress/policy.d.ts

@@ -0,0 +1,32 @@
+import type { NetworkPolicy } from "@vercel/sandbox";
+import type { TracePropagationHeaders } from "@/chat/logging";
+import { type SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+/** Return whether an outbound host is covered by a provider domain rule. */
+export declare function matchesSandboxEgressDomain(host: string, domain: string): boolean;
+/**
+ * Resolve the plugin provider responsible for an outbound sandbox host.
+ *
+ * Only plugin-declared provider domains are eligible for credentialed sandbox
+ * egress. Hosts without a matching provider are blocked by the proxy even if a
+ * malformed or stale network policy tried to forward them.
+ */
+export declare function resolveSandboxEgressProviderForHost(host: string): string | undefined;
+/**
+ * Build the policy that forwards provider domains through the egress proxy.
+ *
+ * The signed credential token is embedded in the forward URL so the proxy can
+ * bind each forwarded request back to the actor and sandbox VM that created the
+ * command. The sandbox receives placeholder env vars, not provider credentials.
+ */
+export declare function buildSandboxEgressNetworkPolicy(input?: {
+    credentialToken?: string;
+    traceConfig?: SandboxEgressTracePropagationConfig;
+    traceHeaders?: TracePropagationHeaders;
+}): NetworkPolicy;
+/**
+ * Resolve non-secret command environment values for registered sandbox providers.
+ *
+ * Credential env vars are placeholders that tell tools which auth variable name
+ * exists; real credential headers are issued lazily by host egress.
+ */
+export declare function resolveSandboxCommandEnvironment(): Promise<Record<string, string>>;

package/dist/chat/sandbox/egress/proxy.d.ts

@@ -0,0 +1,35 @@
+import { type CredentialedEgressHttpInterceptor } from "@/chat/egress/credentialed";
+import { type SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+import type { JWTPayload } from "jose";
+/**
+ * Intercepts a verified sandbox HTTP request before live provider forwarding.
+ *
+ * The hook runs after OIDC, forwarded URL validation, provider ownership, and
+ * credential-context checks have succeeded.
+ */
+export type SandboxEgressHttpInterceptor = CredentialedEgressHttpInterceptor;
+/** Runtime dependencies for the sandbox egress proxy boundary. */
+interface ProxyDeps {
+    fetch?: typeof fetch;
+    interceptHttp?: SandboxEgressHttpInterceptor;
+    tracePropagation?: SandboxEgressTracePropagationConfig;
+    verifyOidc?: (token: string) => Promise<JWTPayload>;
+}
+/**
+ * Return whether a request carries the forwarding headers expected from Vercel.
+ *
+ * This is only a cheap classifier for routing into the proxy handler. Real
+ * authentication happens in `proxySandboxEgressRequest` by verifying the OIDC
+ * token and signed Junior credential context.
+ */
+export declare function isSandboxEgressForwardedRequest(request: Request): boolean;
+/**
+ * Handle one forwarded sandbox egress request.
+ *
+ * This is the public proxy boundary: it rejects unauthenticated VM requests,
+ * rejects forwarded URLs outside plugin-owned provider domains, rejects signed
+ * credential contexts that do not match the active VM id, and only then asks
+ * `execute.ts` to issue credentials and contact the upstream provider.
+ */
+export declare function proxySandboxEgressRequest(request: Request, deps?: ProxyDeps): Promise<Response>;
+export {};

package/dist/chat/sandbox/{egress-session.d.ts → egress/session.d.ts}

@@ -1,30 +1,60 @@
 import type { CredentialContext } from "@/chat/credentials/context";
-import { type SandboxEgressAuthRequiredSignal, type SandboxEgressCredentialContext, type SandboxEgressCredentialLease, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress-schemas";
+import { type SandboxEgressAuthRequiredSignal, type SandboxEgressCredentialContext, type SandboxEgressCredentialLease, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/schemas";
 export declare const SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
 export type { SandboxEgressAuthRequiredSignal, SandboxEgressCredentialContext, SandboxEgressCredentialLease, SandboxEgressPermissionDeniedSignal, };
-/** Create a signed actor/sandbox context token for lazy sandbox egress auth. */
+/**
+ * Create the signed Junior credential context embedded in the proxy URL.
+ *
+ * The token binds requester credentials to a specific sandbox egress id and a
+ * short expiry. Vercel OIDC proves which VM sent a request; this token proves
+ * which Junior actor and credential context that VM is allowed to use.
+ */
 export declare function createSandboxEgressCredentialToken(input: {
     credentials: CredentialContext;
     egressId: string;
     ttlMs?: number;
 }): string;
-/** Verify a signed actor/sandbox context token from the proxy URL. */
+/**
+ * Verify the signed Junior credential context from the proxy URL.
+ *
+ * Returning `undefined` means the token is missing, expired, malformed, or not
+ * signed with the current `JUNIOR_SECRET`.
+ */
 export declare function parseSandboxEgressCredentialToken(token: string | undefined): SandboxEgressCredentialContext | undefined;
-/** Cache a short-lived credential lease for one actor/sandbox context and grant. */
+/**
+ * Cache credential header transforms for one actor, VM, context token, and grant.
+ *
+ * The cache TTL is capped by both the provider lease expiry and the signed
+ * context expiry so a stale sandbox URL cannot keep using old credentials.
+ */
 export declare function setSandboxEgressCredentialLease(context: SandboxEgressCredentialContext, lease: SandboxEgressCredentialLease): Promise<void>;
-/** Load a cached egress credential lease for one actor/sandbox context and grant. */
+/**
+ * Load cached credential header transforms for the exact actor/context/grant.
+ */
 export declare function getSandboxEgressCredentialLease(provider: string, grantName: string, context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
-/** Clear a cached egress credential lease after the provider rejects its headers. */
+/** Clear a cached lease after the upstream provider rejects its auth headers. */
 export declare function clearSandboxEgressCredentialLease(provider: string, grantName: string, context: SandboxEgressCredentialContext): Promise<void>;
-/** Record that host-side sandbox egress returned an auth-required response. */
+/**
+ * Record that credential issuance needs user authorization for this command.
+ *
+ * The command runner consumes this after the sandbox tool finishes so the agent
+ * can present a normal authorization-required response instead of a raw proxy
+ * failure.
+ */
 export declare function setSandboxEgressAuthRequiredSignal(context: SandboxEgressCredentialContext, signal: Omit<SandboxEgressAuthRequiredSignal, "createdAtMs" | "kind"> & {
     kind?: SandboxEgressAuthRequiredSignal["kind"];
 }): Promise<void>;
-/** Record that host-side sandbox egress saw an upstream permission denial. */
+/**
+ * Record that the provider rejected an issued credential with permission denial.
+ */
 export declare function setSandboxEgressPermissionDeniedSignal(context: SandboxEgressCredentialContext, signal: Omit<SandboxEgressPermissionDeniedSignal, "createdAtMs">): Promise<void>;
-/** Remove any pending host-side sandbox egress signals for a command. */
+/** Remove pending auth/permission signals before or after a sandbox command. */
 export declare function clearSandboxEgressSignals(egressId: string | undefined): Promise<void>;
-/** Consume the host-side sandbox egress auth signal produced during a command. */
+/**
+ * Consume the auth signal produced during a sandbox command, preferring writes.
+ */
 export declare function consumeSandboxEgressAuthRequiredSignal(egressId: string | undefined): Promise<SandboxEgressAuthRequiredSignal | undefined>;
-/** Consume the host-side sandbox egress permission signal produced during a command. */
+/**
+ * Consume the permission signal produced during a sandbox command, preferring writes.
+ */
 export declare function consumeSandboxEgressPermissionDeniedSignal(egressId: string | undefined): Promise<SandboxEgressPermissionDeniedSignal | undefined>;

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

@@ -1,6 +1,6 @@
 import { type LogContext } from "@/chat/logging";
-import { type SandboxEgressAuthRequiredSignal, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress-session";
-import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
+import { type SandboxEgressAuthRequiredSignal, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/session";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { PluginHookRunner } from "@/chat/plugins/agent-hooks";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";

package/dist/chat/services/pending-auth.d.ts

@@ -28,4 +28,9 @@ export declare function applyPendingAuthUpdate(args: {
     conversationId: string | undefined;
     nextPendingAuth: ConversationPendingAuthState;
 }): Promise<void>;
+/**
+ * Decide whether an auth callback still belongs to the latest real human
+ * request, ignoring bot-authored and passive bystander rows while treating
+ * failed human turns and opt-outs as newer freshness blockers.
+ */
 export declare function isPendingAuthLatestRequest(conversation: ThreadConversationState, pendingAuth: ConversationPendingAuthState): boolean;

package/dist/chat/slack/client.d.ts

@@ -28,6 +28,8 @@ export declare class SlackActionError extends Error {
 interface SlackRetryContext {
     action?: string;
     attributes?: Record<string, string | number | boolean>;
+    /** Extra attributes forwarded onto the per-attempt Sentry span. */
+    spanAttributes?: Record<string, string | number | boolean>;
 }
 /** Extract a header value by case-insensitive name from a raw headers object. */
 export declare function getHeaderString(headers: unknown, name: string): string | undefined;

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

@@ -15,6 +15,25 @@ export interface SlackConversationMessageMetadata {
     route: SlackConversationRoute;
     thread: SerializedThread;
 }
+interface SlackResourceEventInboundInput {
+    event: {
+        eventKey: string;
+        eventType: string;
+        occurredAtMs: number;
+        provider: string;
+        resourceRef: string;
+    };
+    subscription: {
+        conversationId: string;
+        destination: {
+            channelId: string;
+            platform: "slack";
+            teamId: string;
+        };
+        id: string;
+    };
+    text: string;
+}
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
@@ -23,6 +42,8 @@ export interface CreateSlackConversationWorkerOptions {
     runtime: Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
     state?: StateAdapter;
 }
+/** Create a Slack mailbox record for a subscribed resource-event notification. */
+export declare function createSlackResourceEventInboundMessage(input: SlackResourceEventInboundInput): InboundMessage;
 /** Build the worker run function for queued Slack conversation work. */
 export declare function createSlackConversationWorker(options: CreateSlackConversationWorkerOptions): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Serialize a Slack message into the generic durable conversation mailbox. */
@@ -34,3 +55,4 @@ export declare function buildSlackInboundMessage(args: {
     route: SlackConversationRoute;
     thread: ThreadImpl;
 }): InboundMessage;
+export {};

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

@@ -6,7 +6,7 @@ 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 Source = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
 export type ExecutionStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
 export interface AgentInput {
     attachments?: unknown[];
@@ -153,6 +153,12 @@ export declare function markConversationWorkEnqueued(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<void>;
+/** Clear a wake marker after its queue delivery finds no runnable work. */
+export declare function clearConsumedConversationWake(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Try to acquire the durable execution lease for one conversation. */
 export declare function startConversationWork(args: {
     conversationId: string;

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

@@ -4,6 +4,12 @@ import type { ConversationWorkQueue } from "./queue";
 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";
+export type EnsureConversationWakeResult = {
+    queueMessageId?: string;
+    status: "enqueued";
+} | {
+    status: "already_enqueued" | "no_work";
+};
 /** Return a persisted conversation record, if one exists. */
 export declare function getConversation(args: {
     conversationId: string;
@@ -18,6 +24,22 @@ export declare function getConversationWorkState(args: {
 export declare function countPendingConversationMessages(conversation: Conversation): number;
 /** Return whether a conversation has pending or resumable execution work. */
 export declare function hasRunnableConversationWork(conversation: Conversation): boolean;
+/**
+ * Ensure runnable conversation work has one accepted queue wake-up nudge.
+ *
+ * Ordinary wakes coalesce on a recent accepted marker. Replacement is only for
+ * consumed or known-stale deliveries where another queue nudge must exist.
+ */
+export declare function ensureConversationWake(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    delayMs?: number;
+    idempotencyKey: string;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    replaceExistingWake?: true;
+    state?: StateAdapter;
+}): Promise<EnsureConversationWakeResult>;
 /** Persist one inbound message idempotently in its conversation mailbox. */
 export declare function appendInboundMessage(args: {
     message: InboundMessage;
@@ -25,7 +47,7 @@ export declare function appendInboundMessage(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<workState.AppendInboundMessageResult>;
-/** Persist inbound work and send the queue nudge that wakes a worker. */
+/** Persist inbound work and ensure a worker wake-up. */
 export declare function appendAndEnqueueInboundMessage(args: {
     message: InboundMessage;
     conversationStore?: ConversationStore;
@@ -33,6 +55,13 @@ export declare function appendAndEnqueueInboundMessage(args: {
     queue: ConversationWorkQueue;
     state?: StateAdapter;
 }): Promise<AppendAndEnqueueInboundMessageResult>;
+/** Clear an accepted wake marker after its delivery finds no runnable work. */
+export declare function clearConsumedConversationWake(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Mark a conversation runnable when there is no new mailbox message. */
 export declare function requestConversationWork(args: {
     conversationId: string;
@@ -46,13 +75,6 @@ export declare function recordConversationActivity(args: Parameters<Conversation
     conversationStore?: ConversationStore;
     state?: StateAdapter;
 }): 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;