@sentry/junior 0.54.0 → 0.56.0

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

@@ -0,0 +1,6 @@
+import type { HeartbeatHookContext } from "@sentry/junior-plugin-api";
+/** Build the plugin-scoped heartbeat context that gates durable dispatch access. */
+export declare function createHeartbeatContext(args: {
+    nowMs: number;
+    plugin: string;
+}): HeartbeatHookContext;

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

@@ -0,0 +1,14 @@
+/** Re-drive stale core dispatches before invoking plugin heartbeat hooks. */
+export declare function recoverStaleDispatches(args: {
+    limit?: number;
+    nowMs: number;
+}): Promise<number>;
+/** Run trusted plugin heartbeat hooks with bounded per-invocation work. */
+export declare function runTrustedPluginHeartbeats(args: {
+    limit?: number;
+    nowMs: number;
+}): Promise<void>;
+/** Run the core heartbeat phases. */
+export declare function runHeartbeat(args: {
+    nowMs: number;
+}): Promise<void>;

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

@@ -0,0 +1,9 @@
+import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
+import { scheduleDispatchCallback } from "./signing";
+import type { DispatchCallback } from "./types";
+export interface AgentDispatchRunnerDeps {
+    generateAssistantReply?: typeof generateAssistantReplyImpl;
+    scheduleCallback?: typeof scheduleDispatchCallback;
+}
+/** Run one serverless slice for a core-owned agent dispatch. */
+export declare function runAgentDispatchSlice(callback: DispatchCallback, deps?: AgentDispatchRunnerDeps): Promise<void>;

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

@@ -0,0 +1,5 @@
+import type { DispatchCallback } from "./types";
+/** Schedule an authenticated internal callback to run a dispatched agent slice. */
+export declare function scheduleDispatchCallback(callback: DispatchCallback): Promise<void>;
+/** Verify and parse an authenticated agent dispatch callback request. */
+export declare function verifyDispatchCallbackRequest(request: Request): Promise<DispatchCallback | undefined>;

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

@@ -0,0 +1,29 @@
+import type { StateAdapter } from "chat";
+import type { DispatchCreateResult, DispatchOptions, DispatchProjection, DispatchRecord, DispatchStatus } from "./types";
+/** Keep dispatch persistence keys consistent across callback and recovery paths. */
+export declare function getDispatchStorageKey(id: string): string;
+/** Map a dispatch destination to the conversation lock and memory key it owns. */
+export declare function getDispatchConversationId(destination: DispatchRecord["destination"]): string;
+/** Give dispatch slices stable turn ids for resumability and trace correlation. */
+export declare function getDispatchTurnId(dispatchId: string): string;
+/** Gate recovery to dispatches that can still make progress. */
+export declare function isTerminalDispatchStatus(status: DispatchStatus): boolean;
+/** Serialize mutations for a dispatch so callbacks and heartbeats stay idempotent. */
+export declare function withDispatchLock<T>(dispatchId: string, callback: (state: StateAdapter) => Promise<T>): Promise<T>;
+/** Load dispatch state for callback, recovery, and plugin projection paths. */
+export declare function getDispatchRecord(id: string): Promise<DispatchRecord | undefined>;
+/** Create a plugin dispatch idempotently from the plugin's idempotency key. */
+export declare function createOrGetDispatch(args: {
+    nowMs: number;
+    options: DispatchOptions;
+    plugin: string;
+}): Promise<DispatchCreateResult>;
+/** Advance dispatch versions so stale callbacks cannot overwrite newer state. */
+export declare function updateDispatchRecord(state: StateAdapter, record: DispatchRecord): Promise<DispatchRecord>;
+/** Feed heartbeat recovery from the durable incomplete-dispatch index. */
+export declare function listIncompleteDispatchIds(): Promise<string[]>;
+/** Return a plugin-scoped dispatch projection without exposing raw runtime state. */
+export declare function getPluginDispatchProjection(args: {
+    id: string;
+    plugin: string;
+}): Promise<DispatchProjection | undefined>;

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

@@ -0,0 +1,57 @@
+export type DispatchStatus = "pending" | "running" | "awaiting_resume" | "completed" | "failed" | "blocked";
+export interface DispatchActor {
+    type: "system";
+    id: string;
+}
+export interface DispatchDestination {
+    platform: "slack";
+    teamId: string;
+    channelId: string;
+}
+export interface DispatchCredentialSubject {
+    type: "user";
+    userId: string;
+    allowedWhen: "private-direct-conversation";
+}
+export interface DispatchOptions {
+    credentialSubject?: DispatchCredentialSubject;
+    destination: DispatchDestination;
+    idempotencyKey: string;
+    input: string;
+    metadata?: Record<string, string>;
+}
+export interface DispatchRecord {
+    actor: DispatchActor;
+    attempt: number;
+    createdAtMs: number;
+    credentialSubject?: DispatchCredentialSubject;
+    destination: DispatchDestination;
+    errorMessage?: string;
+    id: string;
+    idempotencyKey: string;
+    input: string;
+    lastCallbackAtMs?: number;
+    leaseExpiresAtMs?: number;
+    maxAttempts: number;
+    metadata?: Record<string, string>;
+    plugin: string;
+    resultMessageTs?: string;
+    resumeCheckpointVersion?: number;
+    status: DispatchStatus;
+    updatedAtMs: number;
+    version: number;
+}
+export interface DispatchProjection {
+    errorMessage?: string;
+    id: string;
+    resultMessageTs?: string;
+    status: DispatchStatus;
+}
+export interface DispatchCallback {
+    expectedVersion: number;
+    id: string;
+}
+export interface DispatchCreateResult {
+    record: DispatchRecord;
+    status: "created" | "already_exists";
+}

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

@@ -0,0 +1,3 @@
+import type { DispatchOptions } from "./types";
+/** Validate plugin-provided dispatch options before core persists them. */
+export declare function validateDispatchOptions(options: DispatchOptions): void;

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

@@ -1,15 +1,18 @@
 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 VisionContextDeps, type VisionContextService } from "@/chat/services/vision-context";
 export interface JuniorRuntimeServices {
     conversationMemory: ConversationMemoryService;
+    contextCompactor: ContextCompactor;
     replyExecutor: ReplyExecutorServices;
     subscribedReplyPolicy: SubscribedReplyPolicy;
     visionContext: VisionContextService;
 }
 export interface JuniorRuntimeServiceOverrides {
     conversationMemory?: Partial<ConversationMemoryDeps>;
+    contextCompactor?: Partial<ContextCompactorDeps>;
     replyExecutor?: Partial<Omit<ReplyExecutorServices, "generateThreadTitle">>;
     subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
     visionContext?: Partial<VisionContextDeps>;

package/dist/chat/config.d.ts

@@ -5,6 +5,7 @@ export interface BotConfig {
     fastModelId: string;
     loadingMessages: string[];
     modelId: string;
+    modelContextWindowTokens?: number;
     visionModelId?: string;
     turnTimeoutMs: number;
     userName: string;
@@ -24,6 +25,7 @@ export interface ChatConfig {
     };
     state: {
         adapter: "memory" | "redis";
+        keyPrefix?: string;
         redisUrl?: string;
     };
 }

package/dist/chat/ingress/workspace-membership.d.ts

@@ -1,5 +1,4 @@
-/** Run a callback with the workspace team ID available for membership checks. */
-export declare function runWithWorkspaceTeamId<T>(teamId: string | undefined, fn: () => T): T;
+export { runWithWorkspaceTeamId } from "@/chat/slack/workspace-context";
 /**
  * Return true when a Slack event's author is from an external workspace.
  *

package/dist/chat/logging.d.ts

@@ -20,6 +20,8 @@ export interface LogContext {
     slackUserName?: string;
     slackChannelId?: string;
     runId?: string;
+    actorType?: string;
+    actorId?: string;
     assistantUserName?: string;
     modelId?: string;
     skillName?: string;

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

@@ -23,6 +23,7 @@ export declare function completeText(params: {
     modelId: string;
     system?: string;
     messages: Message[];
+    messageAttributeMode?: "content" | "metadata";
     thinkingLevel?: ThinkingLevel;
     temperature?: number;
     maxTokens?: number;

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

@@ -0,0 +1,32 @@
+import type { AgentPluginRequester, JuniorPlugin } from "@sentry/junior-plugin-api";
+import type { ToolDefinition } from "@/chat/tools/definition";
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+import type { SandboxInstance } from "@/chat/sandbox/workspace";
+/** Signal that a trusted plugin intentionally denied a tool execution. */
+export declare class AgentPluginHookDeniedError extends Error {
+    constructor(message: string);
+}
+export interface ToolHookInput {
+    input: Record<string, unknown>;
+    name: string;
+}
+export interface ToolHookResult {
+    env: Record<string, string>;
+    input: Record<string, unknown>;
+}
+export interface AgentPluginHookRunner {
+    beforeToolExecute(input: ToolHookInput): Promise<ToolHookResult>;
+    prepareSandbox(sandbox: SandboxInstance): Promise<void>;
+}
+/** Validate trusted plugin identity before it can affect process-wide hooks. */
+export declare function validateAgentPlugins(plugins: JuniorPlugin[]): void;
+/** Replace trusted agent plugins and return the previous list for rollback. */
+export declare function setAgentPlugins(plugins: JuniorPlugin[]): JuniorPlugin[];
+/** Return the current trusted agent plugins without exposing mutable state. */
+export declare function getAgentPlugins(): JuniorPlugin[];
+/** Collect turn-scoped tools exposed by trusted plugins. */
+export declare function getAgentPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
+/** Create one runner over trusted agent plugins registered by the app. */
+export declare function createAgentPluginHookRunner(input?: {
+    requester?: AgentPluginRequester;
+}): AgentPluginHookRunner;

package/dist/chat/plugins/logging.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPluginLogger } from "@sentry/junior-plugin-api";
+/** Create the host logger exposed to trusted plugin hooks. */
+export declare function createAgentPluginLogger(plugin: string): AgentPluginLogger;

package/dist/chat/plugins/state.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPluginState } from "@sentry/junior-plugin-api";
+/** Create a durable state namespace scoped to one trusted plugin. */
+export declare function createPluginState(plugin: string): AgentPluginState;

package/dist/chat/respond.d.ts

@@ -6,13 +6,20 @@ import type { PiMessage } from "@/chat/pi/messages";
 import { type SandboxAcquiredState } from "@/chat/sandbox/sandbox";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import { type AssistantReply, type AgentTurnDiagnostics } from "@/chat/services/turn-result";
+import { type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 export type { AssistantReply, AgentTurnDiagnostics };
 export interface ReplyRequestContext {
     skillDirs?: string[];
+    credentialSubject?: {
+        type: "user";
+        userId: string;
+        allowedWhen: "private-direct-conversation";
+    };
     requester?: {
         userId?: string;
         userName?: string;
         fullName?: string;
+        email?: string;
     };
     correlation?: {
         conversationId?: string;
@@ -20,14 +27,18 @@ export interface ReplyRequestContext {
         turnId?: string;
         runId?: string;
         channelId?: string;
+        teamId?: string;
         messageTs?: string;
         threadTs?: string;
         requesterId?: string;
+        actorType?: string;
+        actorId?: string;
     };
     toolChannelId?: string;
     conversationContext?: string;
     artifactState?: ThreadArtifactsState;
     pendingAuth?: ConversationPendingAuthState;
+    authorizationFlowMode?: AuthorizationFlowMode;
     configuration?: Record<string, unknown>;
     /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
     piMessages?: PiMessage[];

package/dist/chat/runtime/reply-executor.d.ts

@@ -3,9 +3,11 @@ import type { SlackAdapter } from "@chat-adapter/slack";
 import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
 import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
 import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
 import type { TurnContinuationRequest } from "@/chat/services/timeout-resume";
 export interface ReplyExecutorServices {
+    contextCompactor: ContextCompactor;
     generateAssistantReply: typeof generateAssistantReplyImpl;
     generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
     getAwaitingTurnContinuationRequest: (args: {

package/dist/chat/runtime/thread-context.d.ts

@@ -20,3 +20,5 @@ export declare function getAssistantThreadContext(message: Message): {
     threadTs: string;
 } | undefined;
 export declare function getMessageTs(message: Message): string | undefined;
+/** Resolve the Slack workspace/team id from the raw inbound message payload. */
+export declare function getTeamId(message: Message): string | undefined;

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

@@ -1,10 +1,17 @@
 import type { JWTPayload } from "jose";
+/** Intercepts a credential-injected sandbox HTTP request before live forwarding. */
+export type SandboxEgressHttpInterceptor = (input: {
+    provider: string;
+    request: Request;
+    upstreamUrl: URL;
+}) => Promise<Response | undefined>;
 interface ProxyDeps {
     fetch?: typeof fetch;
+    interceptHttp?: SandboxEgressHttpInterceptor;
     verifyOidc?: (token: string) => Promise<JWTPayload>;
 }
 /** Return whether a request appears to be from the Vercel Sandbox egress proxy. */
 export declare function isSandboxEgressForwardedRequest(request: Request): boolean;
-/** Proxy one Vercel Sandbox firewall egress request through lazy credential injection. */
+/** Proxy one Vercel Sandbox firewall egress request through lazy credential headers. */
 export declare function proxySandboxEgressRequest(request: Request, deps?: ProxyDeps): Promise<Response>;
 export {};

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

@@ -1,4 +1,5 @@
 import { type LogContext } from "@/chat/logging";
+import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
 interface SandboxExecutionInput {
@@ -43,6 +44,7 @@ export declare function createSandboxExecutor(options?: {
     credentialEgress?: {
         requesterId: string;
     };
+    agentHooks?: AgentPluginHookRunner;
     onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
     runBashCustomCommand?: (command: string) => Promise<{
         handled: boolean;

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

@@ -45,6 +45,7 @@ export declare function createSandboxSessionManager(options?: {
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string) => NetworkPolicy | undefined;
+    onSandboxPrepare?: (sandbox: SandboxInstance) => void | Promise<void>;
     onSandboxAcquired?: (sandbox: {
         sandboxId: string;
         sandboxDependencyProfileHash?: string;

package/dist/chat/sandbox/skill-sync.d.ts

@@ -6,12 +6,11 @@ export declare function resolveHostSkillPath(availableSkills: SkillMetadata[], s
 export declare function resolveHostDataPath(referenceFiles: string[], sandboxPath: string): string | null;
 /** Detect missing host-backed skill files so reads can fall back to the sandbox copy. */
 export declare function isHostFileMissingError(error: unknown): boolean;
-/** Copy the current skill set and reference files into a sandbox and mark runtime shims executable. */
+/** Copy the current skill set and reference files into a sandbox. */
 export declare function syncSkillsToSandbox(params: {
     sandbox: SandboxInstance;
     skills: SkillMetadata[];
     referenceFiles?: string[];
     withSpan: <T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>) => Promise<T>;
-    runtimeBinDir: string;
     workspaceRoot?: string;
 }): Promise<void>;

package/dist/chat/scheduler/cadence.d.ts

@@ -0,0 +1,24 @@
+import type { ScheduledCalendarFrequency, ScheduledTask, ScheduledTaskRecurrence } from "@/chat/scheduler/types";
+/** Parse an ISO timestamp into a finite Unix timestamp in milliseconds. */
+export declare function parseScheduleTimestamp(value: string): number | undefined;
+export interface ZonedDateTimeParts {
+    day: number;
+    hour: number;
+    minute: number;
+    month: number;
+    second: number;
+    weekday: number;
+    year: number;
+}
+/** Resolve a UTC timestamp into calendar parts for a named time zone. */
+export declare function getZonedDateTimeParts(timestampMs: number, timezone: string): ZonedDateTimeParts;
+/** Build a calendar recurrence anchored to an exact first run timestamp. */
+export declare function buildCalendarRecurrence(args: {
+    frequency: ScheduledCalendarFrequency;
+    interval?: number;
+    nextRunAtMs: number;
+    timezone: string;
+    weekdays?: number[];
+}): ScheduledTaskRecurrence;
+/** Return the next fire time after a completed run, when the task recurs. */
+export declare function getNextRunAtMs(task: ScheduledTask, scheduledForMs: number, afterMs?: number): number | undefined;

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

@@ -0,0 +1,2 @@
+/** Create Junior's built-in trusted scheduler plugin. */
+export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").JuniorPlugin;

package/dist/chat/scheduler/prompt.d.ts

@@ -0,0 +1,7 @@
+import { type ScheduledRun, type ScheduledTask } from "@/chat/scheduler/types";
+/** Build the marker-delimited user prompt for one scheduled task execution. */
+export declare function buildScheduledTaskRunPrompt(args: {
+    nowMs: number;
+    run: ScheduledRun;
+    task: ScheduledTask;
+}): string;

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

@@ -0,0 +1,49 @@
+import type { StateAdapter } from "chat";
+import type { ScheduledRun, ScheduledTask } from "@/chat/scheduler/types";
+export interface SchedulerStore {
+    claimDueRun(args: {
+        nowMs: number;
+    }): Promise<ScheduledRun | undefined>;
+    getRun(runId: string): Promise<ScheduledRun | undefined>;
+    getTask(taskId: string): Promise<ScheduledTask | undefined>;
+    listIncompleteRuns(): Promise<ScheduledRun[]>;
+    listTasksForTeam(teamId: string): Promise<ScheduledTask[]>;
+    markRunBlocked(args: {
+        completedAtMs: number;
+        errorMessage: string;
+        runId: string;
+        startedAtMs?: number;
+    }): Promise<ScheduledRun | undefined>;
+    markRunCompleted(args: {
+        completedAtMs: number;
+        resultMessageTs?: string;
+        runId: string;
+        startedAtMs: number;
+    }): Promise<ScheduledRun | undefined>;
+    markRunFailed(args: {
+        completedAtMs: number;
+        errorMessage: string;
+        startedAtMs?: number;
+        runId: string;
+    }): Promise<ScheduledRun | undefined>;
+    markRunSkipped(args: {
+        completedAtMs: number;
+        errorMessage: string;
+        runId: string;
+    }): Promise<ScheduledRun | undefined>;
+    markRunDispatched(args: {
+        claimedAtMs: number;
+        dispatchId: string;
+        nowMs: number;
+        runId: string;
+    }): Promise<ScheduledRun | undefined>;
+    saveTask(task: ScheduledTask): Promise<void>;
+    updateTaskAfterRun(args: {
+        errorMessage?: string;
+        nowMs: number;
+        run: ScheduledRun;
+        status: "blocked" | "completed" | "failed";
+    }): Promise<void>;
+}
+/** Create the production scheduler store backed by Junior's state adapter. */
+export declare function createStateSchedulerStore(stateAdapter?: StateAdapter): SchedulerStore;

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

@@ -0,0 +1,86 @@
+export type ScheduledTaskStatus = "active" | "paused" | "blocked" | "deleted";
+export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
+export interface ScheduledTaskPrincipal {
+    slackUserId: string;
+    fullName?: string;
+    userName?: string;
+}
+export interface ScheduledTaskExecutionActor {
+    type: "system";
+    id: string;
+}
+export declare const SCHEDULED_TASK_SYSTEM_ACTOR: Readonly<{
+    type: "system";
+    id: string;
+}>;
+export interface ScheduledTaskDestination {
+    platform: "slack";
+    teamId: string;
+    channelId: string;
+}
+export interface ScheduledTaskConversationAccess {
+    audience: "direct" | "group" | "channel";
+    visibility: "private" | "public" | "unknown";
+}
+export interface ScheduledTaskCredentialSubject {
+    type: "user";
+    userId: string;
+    allowedWhen: "private-direct-conversation";
+}
+export type ScheduledCalendarFrequency = "daily" | "weekly" | "monthly" | "yearly";
+export interface ScheduledLocalTime {
+    hour: number;
+    minute: number;
+}
+export interface ScheduledTaskRecurrence {
+    dayOfMonth?: number;
+    frequency: ScheduledCalendarFrequency;
+    interval: number;
+    month?: number;
+    startDate: string;
+    time: ScheduledLocalTime;
+    weekdays?: number[];
+}
+export interface ScheduledTaskSchedule {
+    description: string;
+    timezone: string;
+    kind: "one_off" | "recurring";
+    recurrence?: ScheduledTaskRecurrence;
+}
+export interface ScheduledTaskSpec {
+    text: string;
+}
+export interface ScheduledTask {
+    id: string;
+    createdAtMs: number;
+    createdBy: ScheduledTaskPrincipal;
+    conversationAccess?: ScheduledTaskConversationAccess;
+    credentialSubject?: ScheduledTaskCredentialSubject;
+    destination: ScheduledTaskDestination;
+    executionActor?: ScheduledTaskExecutionActor;
+    lastRunAtMs?: number;
+    nextRunAtMs?: number;
+    originalRequest?: string;
+    runNowAtMs?: number;
+    schedule: ScheduledTaskSchedule;
+    status: ScheduledTaskStatus;
+    statusReason?: string;
+    task: ScheduledTaskSpec;
+    updatedAtMs: number;
+    version: number;
+}
+export interface ScheduledRun {
+    id: string;
+    attempt: number;
+    claimedAtMs: number;
+    completedAtMs?: number;
+    dispatchId?: string;
+    errorMessage?: string;
+    idempotencyKey: string;
+    resultMessageTs?: string;
+    scheduledForMs: number;
+    startedAtMs?: number;
+    status: ScheduledRunStatus;
+    taskId: string;
+    taskVersion: number;
+}

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

@@ -1,5 +1,6 @@
 export type AuthorizationPauseKind = "mcp" | "plugin";
 export type AuthorizationPauseDisposition = "link_already_sent" | "link_sent";
+export type AuthorizationFlowMode = "interactive" | "disabled";
 /**
  * Runtime-owned signal that the current turn must park until the user
  * completes an external authorization step.
@@ -10,3 +11,9 @@ export declare class AuthorizationPauseError extends Error {
     readonly provider: string;
     constructor(kind: AuthorizationPauseKind, provider: string, disposition: AuthorizationPauseDisposition);
 }
+/** Error indicating this turn cannot start an external authorization flow. */
+export declare class AuthorizationFlowDisabledError extends Error {
+    readonly kind: AuthorizationPauseKind;
+    readonly provider: string;
+    constructor(kind: AuthorizationPauseKind, provider: string);
+}

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

@@ -0,0 +1,14 @@
+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 post-compaction target from the automatic trigger threshold. */
+export declare function calculateContextCompactionTargetTokens(triggerTokens: number): number;
+/** Resolve the automatic compaction threshold for the active agent model. */
+export declare function getAgentContextCompactionTriggerTokens(): number;
+/** Resolve the visible conversation compaction threshold for the auxiliary model. */
+export declare function getConversationContextCompactionTriggerTokens(): number;

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

@@ -0,0 +1,33 @@
+import type { completeText } from "@/chat/pi/client";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+export interface ContextCompactorDeps {
+    completeText: typeof completeText;
+    autoCompactionTriggerTokens?: number;
+}
+export interface ContextCompactor {
+    maybeCompact: (args: CompactContextArgs) => Promise<CompactContextResult>;
+}
+export interface CompactContextArgs {
+    conversation: ThreadConversationState;
+    conversationContext?: string;
+    conversationId: string;
+    onCompactionStart?: () => void;
+    previousSessionId: string;
+    metadata?: {
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadId?: string;
+    };
+}
+export interface CompactContextResult {
+    compacted: boolean;
+    piMessages?: PiMessage[];
+    reason?: "below_threshold" | "missing_context" | "not_completed" | "summary_failed";
+    sessionId?: string;
+}
+/** 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 and checkpoint forks. */
+export declare function createContextCompactor(deps: ContextCompactorDeps): ContextCompactor;

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

@@ -1,5 +1,5 @@
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import { AuthorizationPauseError } from "@/chat/services/auth-pause";
+import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { PluginDefinition } from "@/chat/plugins/types";
@@ -19,6 +19,7 @@ export interface McpAuthOrchestrationDeps {
     getArtifactState: () => ThreadArtifactsState | undefined;
     getMergedArtifactState: () => ThreadArtifactsState;
     onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    authorizationFlowMode?: AuthorizationFlowMode;
 }
 export interface McpAuthOrchestration {
     authProviderFactory: (plugin: PluginDefinition) => Promise<OAuthClientProvider | undefined>;

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

@@ -1,6 +1,6 @@
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
-import { AuthorizationPauseError } from "@/chat/services/auth-pause";
+import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { Skill } from "@/chat/skills";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
@@ -20,6 +20,7 @@ export interface PluginAuthOrchestrationDeps {
     channelConfiguration?: ChannelConfigurationService;
     currentPendingAuth?: ConversationPendingAuthState;
     onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    authorizationFlowMode?: AuthorizationFlowMode;
     userTokenStore?: UserTokenStore;
 }
 export interface PluginAuthOrchestration {

package/dist/chat/slack/assistant-thread/status-scheduler.d.ts

@@ -1,7 +1,7 @@
 import { type AssistantStatusSpec } from "@/chat/slack/assistant-thread/status-render";
 export type TimerHandle = ReturnType<typeof setTimeout>;
 export interface AssistantStatusSession {
-    start: () => void;
+    start: (status?: AssistantStatusSpec) => void;
     stop: () => Promise<void>;
     update: (status: AssistantStatusSpec) => void;
 }