@sentry/junior 0.113.0 → 0.115.0

package/dist/catalog-runtime-Y32UEQLB.js

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

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

@@ -15,7 +15,9 @@ import type { PiMessage } from "@/chat/pi/messages";
 import type { Actor } from "@/chat/actor";
 import type { SandboxRef } from "@/chat/sandbox/ref";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
 import type { AuthorizationFlowMode } from "@/chat/services/auth-pause";
+import type { OAuthAuthorization } from "@/chat/oauth-authorization";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
@@ -94,6 +96,8 @@ export interface AgentRunPolicy {
     skillDirs?: string[];
     /** Per-slice override for app-owned sandbox egress trace propagation. */
     sandboxTracePropagation?: SandboxEgressTracePropagationConfig;
+    /** Per-slice sandbox egress signal storage override. */
+    sandboxEgressSignals?: SandboxEgressSignalTransport;
     toolOverrides?: {
         imageGenerate?: ImageGenerateToolDeps;
         webFetch?: WebFetchToolDeps;
@@ -152,6 +156,8 @@ export interface AgentRunRequest {
     runId?: string;
     input: AgentRunInput;
     routing: AgentRunRouting;
+    /** Surface-owned OAuth state and private delivery capabilities. */
+    authorization?: OAuthAuthorization;
     policy?: AgentRunPolicy;
     state?: AgentRunState;
     observers?: AgentRunObservers;

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

@@ -11,6 +11,7 @@ import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { LogContext } from "@/chat/logging";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
 import type { SandboxRef } from "@/chat/sandbox/ref";
 import { type SandboxTools } from "@/chat/sandbox/sandbox";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
@@ -21,6 +22,7 @@ export interface AgentSandboxOptions {
     skills: SkillMetadata[];
     traceContext: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
+    egressSignals?: SandboxEgressSignalTransport;
     credentialEgress?: CredentialContext;
     actor?: Actor;
     channelConfiguration?: ChannelConfigurationService;

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

@@ -20,6 +20,7 @@ import type { SandboxRef } from "@/chat/sandbox/ref";
 import type { PiMessage } from "@/chat/pi/messages";
 import type { LogContext } from "@/chat/logging";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { OAuthAuthorization } from "@/chat/oauth-authorization";
 import type { Actor } from "@/chat/actor";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { AuthorizationPauseError } from "@/chat/services/auth-pause";
@@ -38,6 +39,7 @@ interface ToolWiringArgs {
     connectedMcpProviders: Set<string>;
     conversationPrivacy?: ConversationPrivacy;
     durability: AgentRunDurability;
+    authorization?: OAuthAuthorization;
     generatedFiles: FileUpload[];
     invokedSkill: SkillMetadata | null;
     observers: AgentRunObservers;

package/dist/chat/config.d.ts

@@ -8,19 +8,21 @@ export declare const FUNCTION_TIMEOUT_BUFFER_SECONDS = 20;
 /** Additional buffer that makes conversation work yield before the hard request deadline. */
 export declare const CONVERSATION_WORK_SOFT_YIELD_BUFFER_SECONDS = 40;
 export interface BotConfig {
+    contextWindowTokens: number;
+    crossActorMidRunMode: CrossActorMidRunMode;
     embeddingModelId: string;
     fastModelId: string;
     imageGenerationModelId: string;
     loadingMessages: string[];
     profiles: Readonly<Record<string, ExecutionProfileConfig>>;
     reasoningLevel?: TurnReasoningLevel;
-    modelContextWindowTokens?: number;
     visionModelId?: string;
     maxSlicesPerTurn: number;
     turnTimeoutMs: number;
     userName: string;
     webSearchModelId: string;
 }
+export type CrossActorMidRunMode = "follow_up" | "steer";
 export type SqlDriver = "neon" | "postgres";
 export interface ChatConfig {
     bot: BotConfig;

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

@@ -27,6 +27,7 @@ export declare const historyReplacementSchema: z.ZodObject<{
         modelId: z.ZodString;
         reasoningLevel: z.ZodOptional<z.ZodString>;
         triggeringToolCallId: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
                 role: z.ZodString;
@@ -62,6 +63,17 @@ export declare const historyReplacementSchema: z.ZodObject<{
         type: z.ZodLiteral<"compaction">;
         modelProfile: z.ZodString;
         modelId: z.ZodString;
+        details: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodLiteral<"capacity">;
+            estimatedInputTokens: z.ZodNumber;
+            replacementInputTokens: z.ZodOptional<z.ZodNumber>;
+            triggerTokens: z.ZodNumber;
+            inputLimitTokens: z.ZodNumber;
+            inputMessageCount: z.ZodNumber;
+            retainedMessageCount: z.ZodNumber;
+            summaryChars: z.ZodNumber;
+        }, z.core.$strict>>;
+        summary: z.ZodOptional<z.ZodString>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
                 role: z.ZodString;
@@ -204,6 +216,24 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
         internal: "internal";
         scheduler: "scheduler";
     }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"turn_routed">;
+    turnId: z.ZodString;
+    modelProfile: z.ZodString;
+    modelId: z.ZodString;
+    reasoningLevel: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodEnum<{
+        configured: "configured";
+        inherited: "inherited";
+        router: "router";
+    }>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"turn_completed">;
     turnId: z.ZodString;
@@ -240,6 +270,7 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     modelId: z.ZodString;
     reasoningLevel: z.ZodOptional<z.ZodString>;
     triggeringToolCallId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
     replacementHistory: z.ZodArray<z.ZodObject<{
         message: z.ZodPipe<z.ZodObject<{
             role: z.ZodString;
@@ -275,6 +306,17 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     type: z.ZodLiteral<"compaction">;
     modelProfile: z.ZodString;
     modelId: z.ZodString;
+    details: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"capacity">;
+        estimatedInputTokens: z.ZodNumber;
+        replacementInputTokens: z.ZodOptional<z.ZodNumber>;
+        triggerTokens: z.ZodNumber;
+        inputLimitTokens: z.ZodNumber;
+        inputMessageCount: z.ZodNumber;
+        retainedMessageCount: z.ZodNumber;
+        summaryChars: z.ZodNumber;
+    }, z.core.$strict>>;
+    summary: z.ZodOptional<z.ZodString>;
     replacementHistory: z.ZodArray<z.ZodObject<{
         message: z.ZodPipe<z.ZodObject<{
             role: z.ZodString;
@@ -447,6 +489,24 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             internal: "internal";
             scheduler: "scheduler";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"turn_routed">;
+        turnId: z.ZodString;
+        modelProfile: z.ZodString;
+        modelId: z.ZodString;
+        reasoningLevel: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            none: "none";
+        }>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodEnum<{
+            configured: "configured";
+            inherited: "inherited";
+            router: "router";
+        }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_completed">;
         turnId: z.ZodString;
@@ -483,6 +543,7 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         modelId: z.ZodString;
         reasoningLevel: z.ZodOptional<z.ZodString>;
         triggeringToolCallId: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
                 role: z.ZodString;
@@ -518,6 +579,17 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"compaction">;
         modelProfile: z.ZodString;
         modelId: z.ZodString;
+        details: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodLiteral<"capacity">;
+            estimatedInputTokens: z.ZodNumber;
+            replacementInputTokens: z.ZodOptional<z.ZodNumber>;
+            triggerTokens: z.ZodNumber;
+            inputLimitTokens: z.ZodNumber;
+            inputMessageCount: z.ZodNumber;
+            retainedMessageCount: z.ZodNumber;
+            summaryChars: z.ZodNumber;
+        }, z.core.$strict>>;
+        summary: z.ZodOptional<z.ZodString>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
                 role: z.ZodString;
@@ -717,6 +789,24 @@ export declare const newConversationEventSchema: z.ZodObject<{
             internal: "internal";
             scheduler: "scheduler";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"turn_routed">;
+        turnId: z.ZodString;
+        modelProfile: z.ZodString;
+        modelId: z.ZodString;
+        reasoningLevel: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            none: "none";
+        }>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodEnum<{
+            configured: "configured";
+            inherited: "inherited";
+            router: "router";
+        }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_completed">;
         turnId: z.ZodString;
@@ -759,6 +849,8 @@ export interface ConversationEventStore {
     append(conversationId: string, events: NewConversationEvent[]): Promise<void>;
     /** Replace active model history with a compaction or handoff event. */
     replaceHistory(conversationId: string, replacement: HistoryReplacement): Promise<void>;
+    /** One event selected by its retry-stable key across history versions. */
+    loadByIdempotencyKey(conversationId: string, idempotencyKey: string): Promise<ConversationEvent | undefined>;
     /** Events of the current history version in `seq` order. */
     loadCurrentHistory(conversationId: string): Promise<ConversationEvent[]>;
     /** Events in the history version containing `seq`, when it exists. */

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

@@ -1,8 +1,10 @@
 import { type PiMessage } from "@/chat/pi/messages";
 import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
-import type { AuthorizationKind } from "@/chat/conversations/history";
+import type { AuthorizationKind, ConversationEvent } from "@/chat/conversations/history";
 import type { JuniorSqlDatabase } from "@/db/db";
 import { type PiConversationEventProjection, type PiConversationProjection } from "@/chat/pi/conversation-events";
+import type { ModelProfile } from "@/chat/model-profile";
+import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 interface ScopedConversation {
     conversationId: string;
 }
@@ -77,6 +79,23 @@ export declare function recordAuthorizationCompleted(args: {
     actorId: string;
     authorizationId: string;
 }): Promise<void>;
+/** Load a previously selected execution profile for a resumed turn. */
+export declare function loadTurnRoute(args: {
+    conversationId: string;
+    turnId: string;
+}): Promise<Extract<ConversationEvent["data"], {
+    type: "turn_routed";
+}> | undefined>;
+/** Record the execution profile selected for one turn without changing agent history. */
+export declare function recordTurnRoute(args: {
+    conversationId: string;
+    turnId: string;
+    modelProfile: ModelProfile;
+    modelId: string;
+    reasoningLevel: TurnReasoningLevel;
+    confidence?: number;
+    source: "configured" | "inherited" | "router";
+}): Promise<void>;
 /** Record a host-observed parent tool start without adding it to Pi replay. */
 export declare function recordToolExecutionStarted(args: {
     conversationId: string;

package/dist/chat/local/credential-sync.d.ts

@@ -0,0 +1,5 @@
+import { type PluginStoredTokens } from "@sentry/junior-plugin-api";
+/** Copy a local user's provider credential to the loopback dev-server broker. */
+export declare function syncLocalOAuthCredential(provider: string, tokens: PluginStoredTokens): Promise<void>;
+/** Verify and store one credential sent by the local CLI over loopback. */
+export declare function receiveLocalOAuthCredential(request: Request): Promise<Response>;

package/dist/chat/local/oauth-relay.d.ts

@@ -0,0 +1,4 @@
+/** Create an OAuth state value that can be safely relayed to a local CLI callback. */
+export declare function createLocalOAuthState(port: number): Promise<string>;
+/** Redirect a provider callback from the public dev URL to the owning local CLI. */
+export declare function relayLocalOAuthCallback(request: Request): Promise<Response | undefined>;

package/dist/chat/mcp/oauth.d.ts

@@ -17,6 +17,7 @@ export declare function createMcpOAuthClientProvider(input: {
     toolChannelId?: string;
     configuration?: Record<string, unknown>;
     artifactState?: ThreadArtifactsState;
+    createAuthorizationState?: () => Promise<string>;
 }): Promise<StateBackedMcpOAuthClientProvider>;
 /** Exchange a callback code while guarding every shared credential mutation. */
 export declare function finalizeMcpAuthorization(provider: string, authSessionId: string, authorizationCode: string, runCredentialMutation?: <T>(mutation: () => Promise<T>) => Promise<T>): Promise<McpAuthSessionState>;

package/dist/chat/oauth-authorization.d.ts

@@ -0,0 +1,17 @@
+/** User-facing link and guidance for one OAuth authorization attempt. */
+export interface OAuthAuthorizationRequest {
+    authorizationUrl: string;
+    completionText: string;
+    label: string;
+}
+/** Surface-owned capabilities for creating and presenting OAuth authorization. */
+export interface OAuthAuthorization {
+    createState: () => Promise<string>;
+    deliver: (request: OAuthAuthorizationRequest) => void | Promise<void>;
+}
+/** Build the stable event identity shared by authorization request and completion. */
+export declare function authorizationId(args: {
+    kind: "mcp" | "plugin";
+    provider: string;
+    sessionId: string;
+}): string;

package/dist/chat/oauth-flow.d.ts

@@ -1,4 +1,5 @@
 import { type Destination, type Source } from "@sentry/junior-plugin-api";
+import type { OAuthAuthorization, OAuthAuthorizationRequest } from "@/chat/oauth-authorization";
 type PrivateDeliveryResult = "in_context" | "fallback_dm" | false;
 export type OAuthStatePayload = {
     userId: string;
@@ -21,6 +22,7 @@ type OAuthFlowInput = {
     resumeConversationId?: string;
     resumeSessionId?: string;
     scope?: string;
+    authorization?: OAuthAuthorization;
 };
 /** Parse OAuth callback state that was persisted before a provider redirect. */
 export declare function parseOAuthStatePayload(value: unknown): OAuthStatePayload | undefined;
@@ -38,6 +40,13 @@ export declare function deliverPrivateMessage(input: {
     userId: string;
     text: string;
 }): Promise<PrivateDeliveryResult>;
+/** Present one OAuth request through the active surface's private delivery. */
+export declare function deliverOAuthAuthorization(request: OAuthAuthorizationRequest, input: {
+    authorization?: OAuthAuthorization;
+    channelId?: string;
+    threadTs?: string;
+    userId: string;
+}): Promise<PrivateDeliveryResult>;
 /** Initiate an OAuth authorization code flow for a provider and deliver the auth link to the user. */
 export declare function startOAuthFlow(provider: string, input: OAuthFlowInput): Promise<{
     ok: false;

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

@@ -113,6 +113,52 @@ export declare const sandboxEgressPermissionDeniedSignalSchema: z.ZodObject<{
     upstreamPath: z.ZodString;
     createdAtMs: z.ZodNumber;
 }, z.core.$strict>;
+export declare const sandboxEgressSignalsResponseSchema: z.ZodObject<{
+    auth_required: z.ZodOptional<z.ZodObject<{
+        authorization: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            scope: z.ZodOptional<z.ZodString>;
+            type: z.ZodLiteral<"oauth">;
+        }, z.core.$strict>>;
+        grant: z.ZodObject<{
+            access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+            leaseScope: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        kind: z.ZodDefault<z.ZodEnum<{
+            unavailable: "unavailable";
+            auth_required: "auth_required";
+        }>>;
+        provider: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        createdAtMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    permission_denied: z.ZodOptional<z.ZodObject<{
+        account: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        acceptedPermissions: z.ZodOptional<z.ZodString>;
+        grant: z.ZodObject<{
+            access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+            leaseScope: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        message: z.ZodString;
+        provider: z.ZodString;
+        source: z.ZodLiteral<"upstream">;
+        sso: z.ZodOptional<z.ZodString>;
+        status: z.ZodNumber;
+        upstreamHost: z.ZodString;
+        upstreamPath: z.ZodString;
+        createdAtMs: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export type SandboxEgressCredentialContext = z.output<typeof sandboxEgressCredentialContextSchema>;
 export type SandboxEgressGrant = z.output<typeof sandboxEgressGrantSchema>;
 export type SandboxEgressCredentialLease = z.output<typeof sandboxEgressCredentialLeaseSchema>;

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

@@ -0,0 +1,9 @@
+import type { SandboxEgressAuthRequiredSignal, SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/schemas";
+/** Authenticated transport for signal state owned by another Junior process. */
+export interface SandboxEgressSignalTransport {
+    clear: (credentialToken: string) => Promise<void>;
+    consume: (credentialToken: string) => Promise<{
+        authRequired?: SandboxEgressAuthRequiredSignal;
+        permissionDenied?: SandboxEgressPermissionDeniedSignal;
+    }>;
+}

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

@@ -1,4 +1,5 @@
 import { type LogContext } from "@/chat/logging";
+import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { SandboxRef } from "@/chat/sandbox/ref";
@@ -26,6 +27,7 @@ export interface SandboxOptions {
     traceContext?: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;
+    egressSignals?: SandboxEgressSignalTransport;
     prepare?: (workspace: SandboxWorkspace) => void | Promise<void>;
     onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
 }

package/dist/chat/sentry-payload-filter.d.ts

@@ -3,12 +3,12 @@ type SentryErrorEvent = Parameters<NonNullable<Sentry.NodeOptions["beforeSend"]>
 type SentryTransactionEvent = Parameters<NonNullable<Sentry.NodeOptions["beforeSendTransaction"]>>[0];
 type SentrySpan = Parameters<Parameters<typeof Sentry.withStreamedSpan>[0]>[0];
 type SentryLog = Parameters<NonNullable<Sentry.NodeOptions["beforeSendLog"]>>[0];
-/** Remove raw private conversation payloads from Sentry error events. */
+/** Remove private conversation payloads and boundary secrets from error events. */
 export declare function scrubPrivateSentryEvent(event: SentryErrorEvent): SentryErrorEvent | null;
-/** Remove raw private conversation payloads from Sentry transaction events. */
+/** Remove private conversation payloads and boundary secrets from transactions. */
 export declare function scrubPrivateSentryTransaction(event: SentryTransactionEvent): SentryTransactionEvent | null;
-/** Remove raw private conversation payloads from streamed Sentry spans. */
+/** Remove private conversation payloads and boundary secrets from streamed spans. */
 export declare function scrubPrivateSentrySpan(span: SentrySpan): SentrySpan;
-/** Remove raw private conversation payloads from Sentry structured logs. */
+/** Remove private conversation payloads and boundary secrets from structured logs. */
 export declare function scrubPrivateSentryLog(log: SentryLog): SentryLog | null;
 export {};

package/dist/chat/services/context-budget.d.ts

@@ -1,14 +1,19 @@
 export interface ModelContextBudget {
     contextWindow: number;
-    maxTokens: number;
 }
 /** Estimate text tokens with the shared coarse heuristic used for local budgets. */
 export declare function estimateTextTokens(text: string): number;
 /** Derive the automatic compaction threshold from model context capacity. */
 export declare function calculateContextCompactionTriggerTokens(model: ModelContextBudget): number;
+/** Derive the maximum estimated input size with room for uncounted request overhead. */
+export declare function calculateContextInputLimitTokens(model: ModelContextBudget): number;
 /** Derive the post-compaction target from the automatic trigger threshold. */
 export declare function calculateContextCompactionTargetTokens(triggerTokens: number): number;
+/** Cap one model's advertised context capacity with the host bot configuration. */
+export declare function getModelContextBudget(modelId: string): ModelContextBudget;
 /** Resolve the automatic compaction threshold for the active agent model. */
-export declare function getAgentContextCompactionTriggerTokens(): number;
+export declare function getAgentContextCompactionTriggerTokens(modelId: string): number;
+/** Resolve the hard input ceiling for the active agent model. */
+export declare function getAgentContextInputLimitTokens(modelId: string): number;
 /** Resolve the visible conversation compaction threshold for the auxiliary model. */
 export declare function getConversationContextCompactionTriggerTokens(): number;

package/dist/chat/services/context-compaction.d.ts

@@ -1,5 +1,6 @@
 import type { completeText } from "@/chat/pi/client";
 import type { PiMessage } from "@/chat/pi/messages";
+import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import { type ModelProfile } from "@/chat/model-profile";
 export interface ContextCompactorDeps {
@@ -13,7 +14,7 @@ export interface CompactContextArgs {
     conversation: ThreadConversationState;
     conversationContext?: string;
     conversationId: string;
-    onCompactionStart?: () => void;
+    onCompactionStart?: () => void | Promise<void>;
     piMessages: PiMessage[];
     metadata?: {
         channelId?: string;
@@ -21,6 +22,7 @@ export interface CompactContextArgs {
         runId?: string;
         threadId?: string;
     };
+    modelId: string;
 }
 export interface CompactContextResult {
     compacted: boolean;
@@ -41,10 +43,35 @@ interface HandoffContextArgs {
         reasoningLevel?: string;
     };
 }
+interface ActiveContextCompactionArgs {
+    conversationContext?: string;
+    conversationId: string;
+    metadata?: CompactContextArgs["metadata"];
+    modelId: string;
+    modelProfile: ModelProfile;
+    onCompactionStart?: () => void | Promise<void>;
+    pendingMessages?: Array<{
+        message: PiMessage;
+        provenance: ConversationMessageProvenance;
+    }>;
+    piMessages: PiMessage[];
+    signal?: AbortSignal;
+}
+/** Raised when Junior cannot compact history below the active model's hard ceiling. */
+export declare class ContextInputLimitExceededError extends Error {
+    readonly estimatedTokens: number;
+    readonly inputLimitTokens: number;
+    constructor(estimatedTokens: number, inputLimitTokens: number);
+}
 /** Build retained user messages for a compacted Pi replacement history. */
 export declare function selectRetainedUserMessages(messages: PiMessage[], maxTokens?: number): PiMessage[];
 /** Build the service that owns local context compaction. */
 export declare function createContextCompactor(deps: ContextCompactorDeps): ContextCompactor;
 /** Compact the active conversation and durably bind its selected handoff profile. */
 export declare function compactContextForHandoff(args: HandoffContextArgs, deps: Pick<ContextCompactorDeps, "completeText">): Promise<PiMessage[]>;
+/**
+ * Replace oversized active history at Pi's next-turn boundary before another
+ * provider request can observe it.
+ */
+export declare function compactActiveContextIfNeeded(args: ActiveContextCompactionArgs, deps: Pick<ContextCompactorDeps, "completeText">): Promise<CompactContextResult>;
 export {};

package/dist/chat/services/conversation-memory.d.ts

@@ -14,6 +14,7 @@ export interface ConversationMemoryService {
     generateThreadTitle: (sourceText: string) => Promise<string>;
 }
 export declare function generateConversationId(prefix: "assistant" | "backfill" | "compaction" | "turn"): string;
+/** Normalize message boundaries without changing transcript formatting. */
 export declare function normalizeConversationText(text: string): string;
 export declare function updateConversationStats(conversation: ThreadConversationState): void;
 export declare function upsertConversationMessage(conversation: ThreadConversationState, message: ConversationMessage): string;

package/dist/chat/services/mcp-auth-orchestration.d.ts

@@ -2,12 +2,13 @@
  * MCP authorization pause orchestration.
  *
  * This module turns an MCP client auth challenge into Junior's paused-run
- * model: create provider auth state, deliver or reuse a private Slack link,
- * record pending auth, and abort the agent so the OAuth callback can resume the
- * same session.
+ * model: create provider auth state, privately present or reuse its link,
+ * record pending auth, and abort the agent so the OAuth callback can resume
+ * the same session.
  */
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { Destination, Source } from "@sentry/junior-plugin-api";
+import { type OAuthAuthorization } from "@/chat/oauth-authorization";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
@@ -32,6 +33,7 @@ export interface McpAuthOrchestrationInput {
     getMergedArtifactState: () => ThreadArtifactsState;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState | undefined) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;
+    authorization?: OAuthAuthorization;
 }
 export interface McpAuthOrchestration {
     authProviderFactory: (plugin: PluginDefinition) => Promise<OAuthClientProvider | undefined>;

package/dist/chat/services/plugin-auth-orchestration.d.ts

@@ -14,6 +14,7 @@ import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
+import { type OAuthAuthorization } from "@/chat/oauth-authorization";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
     constructor(provider: string, providerDisplayName: string, disposition: "link_already_sent" | "link_sent", requestText?: string);
 }
@@ -35,6 +36,7 @@ export interface PluginAuthOrchestrationInput {
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;
     userTokenStore?: UserTokenStore;
+    authorization?: OAuthAuthorization;
 }
 export interface PluginAuthOrchestration {
     /**

package/dist/chat/services/provider-error.d.ts

@@ -12,6 +12,7 @@ interface ProviderErrorOptions {
     retryable?: boolean;
 }
 interface ProviderErrorDetails {
+    cause?: unknown;
     kind: ProviderErrorKind;
     modelId?: string;
     retryable: boolean;

package/dist/chat/services/turn-router.d.ts

@@ -20,6 +20,7 @@ export interface TurnRoute {
     profile: ModelProfile;
     reasoningLevel: TurnReasoningLevel;
     reason: string;
+    source?: "configured" | "inherited" | "router";
 }
 /** Preserve an explicitly configured reasoning level without invoking the router. */
 export declare function configuredTurnRoute(profile: ModelProfile, reasoningLevel: TurnReasoningLevel, source: "agent_config" | "default" | "profile"): TurnRoute;

package/dist/chat/slack/message-control.d.ts

@@ -0,0 +1,2 @@
+/** Remove the explicit Slack steering marker before building agent input. */
+export declare function stripLeadingSteeringOverride(text: string): string;

package/dist/chat/slack/oauth-authorization-message.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthAuthorizationRequest } from "@/chat/oauth-authorization";
+/** Format the private OAuth authorization prompt for Slack delivery. */
+export declare function formatOAuthAuthorizationMessage(args: OAuthAuthorizationRequest): string;

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

@@ -7,6 +7,7 @@ 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";
 import { type SlackActorProfile } from "@/chat/actor";
+import { type CrossActorMidRunMode } from "@/chat/config";
 declare const slackConversationRouteSchema: z.ZodEnum<{
     mention: "mention";
     subscribed: "subscribed";
@@ -270,6 +271,7 @@ interface SlackResourceEventInboundInput {
     text: string;
 }
 export interface CreateSlackConversationWorkerOptions {
+    crossActorMidRunMode?: CrossActorMidRunMode;
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
     resumeAwaitingContinuation: (conversationId: string, options: {