@sentry/junior 0.65.0 → 0.65.1

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

@@ -1,3 +1,10 @@
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+/** Re-drive stale turn continuations whose internal callback vanished. */
+export declare function recoverStaleTimeoutResumes(args: {
+    conversationWorkQueue?: ConversationWorkQueue;
+    limit?: number;
+    nowMs: number;
+}): Promise<number>;
 /** Re-drive stale core dispatches before invoking plugin heartbeat hooks. */
 export declare function recoverStaleDispatches(args: {
     limit?: number;
@@ -10,5 +17,6 @@ export declare function runTrustedPluginHeartbeats(args: {
 }): Promise<void>;
 /** Run the core heartbeat phases. */
 export declare function runHeartbeat(args: {
+    conversationWorkQueue?: ConversationWorkQueue;
     nowMs: number;
 }): Promise<void>;

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

@@ -1,5 +1,5 @@
 import type { StateAdapter } from "chat";
-import type { DispatchCreateResult, DispatchOptions, DispatchProjection, DispatchRecord, DispatchStatus } from "./types";
+import type { BoundDispatchOptions, DispatchCreateResult, 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 lock key that serializes Slack delivery. */
@@ -17,7 +17,7 @@ export declare function getDispatchRecord(id: string): Promise<DispatchRecord |
 /** Create a plugin dispatch idempotently from the plugin's idempotency key. */
 export declare function createOrGetDispatch(args: {
     nowMs: number;
-    options: DispatchOptions;
+    options: BoundDispatchOptions;
     plugin: string;
 }): Promise<DispatchCreateResult>;
 /** Advance dispatch versions so stale callbacks cannot overwrite newer state. */

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

@@ -1,30 +1,16 @@
+import type { DispatchOptions as AgentPluginDispatchOptions } from "@sentry/junior-plugin-api";
+import type { CredentialSubject, CredentialSystemActor } from "@/chat/credentials/context";
 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 type DispatchOptions = AgentPluginDispatchOptions;
+export type DispatchDestination = DispatchOptions["destination"];
+export interface BoundDispatchOptions extends Omit<DispatchOptions, "credentialSubject"> {
+    credentialSubject?: CredentialSubject;
 }
 export interface DispatchRecord {
-    actor: DispatchActor;
+    actor: CredentialSystemActor;
     attempt: number;
     createdAtMs: number;
-    credentialSubject?: DispatchCredentialSubject;
+    credentialSubject?: CredentialSubject;
     destination: DispatchDestination;
     errorMessage?: string;
     id: string;

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

@@ -1,3 +1,5 @@
-import type { DispatchOptions } from "./types";
+import type { BoundDispatchOptions, DispatchOptions } from "./types";
 /** Validate plugin-provided dispatch options before core persists them. */
 export declare function validateDispatchOptions(options: DispatchOptions): void;
+/** Verify runtime-owned access requirements for delegated dispatch credentials. */
+export declare function verifyDispatchCredentialSubjectAccess(options: BoundDispatchOptions): Promise<void>;

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

@@ -1,6 +1,12 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
-import { JuniorChat } from "@/chat/ingress/junior-chat";
-/** Return the lazily initialized production chat app. */
-export declare function getProductionBot(): JuniorChat<{
-    slack: SlackAdapter;
-}>;
+import { createSlackRuntime } from "@/chat/app/factory";
+import type { SlackWebhookServices } from "@/chat/ingress/slack-webhook";
+import type { VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
+/** Return the lazily initialized production Slack adapter. */
+export declare function getProductionSlackAdapter(): SlackAdapter;
+/** Return the lazily initialized production Slack runtime. */
+export declare function getProductionSlackRuntime(): ReturnType<typeof createSlackRuntime>;
+/** Return production services for Slack webhook ingress. */
+export declare function getProductionSlackWebhookServices(): SlackWebhookServices;
+/** Return the production queue callback options for conversation work. */
+export declare function getProductionConversationWorkOptions(): VercelConversationWorkCallbackOptions;

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

@@ -1,10 +1,11 @@
 import type { CredentialLease } from "@/chat/credentials/broker";
+import type { CredentialContext } from "@/chat/credentials/context";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
 /** Create the user token store used by OAuth-backed credential brokers. */
 export declare function createUserTokenStore(): UserTokenStore;
 /** Issue one provider credential lease for host-side sandbox egress proxying. */
 export declare function issueProviderCredentialLease(input: {
+    context: CredentialContext;
     provider: string;
-    requesterId: string;
     reason: string;
 }): Promise<CredentialLease>;

package/dist/chat/capabilities/router.d.ts

@@ -1,9 +1,10 @@
 import type { CredentialBroker, CredentialLease } from "@/chat/credentials/broker";
+import type { CredentialContext } from "@/chat/credentials/context";
 export interface CredentialRouter {
     issue(input: {
+        context: CredentialContext;
         provider: string;
         reason: string;
-        requesterId?: string;
     }): Promise<CredentialLease>;
 }
 export declare class ProviderCredentialRouter implements CredentialRouter {
@@ -12,8 +13,8 @@ export declare class ProviderCredentialRouter implements CredentialRouter {
         brokersByProvider: Record<string, CredentialBroker>;
     });
     issue(input: {
+        context: CredentialContext;
         provider: string;
         reason: string;
-        requesterId?: string;
     }): Promise<CredentialLease>;
 }

package/dist/chat/config.d.ts

@@ -1,5 +1,10 @@
 declare const ADVISOR_THINKING_LEVELS: readonly ["minimal", "low", "medium", "high", "xhigh"];
 export type AdvisorThinkingLevel = (typeof ADVISOR_THINKING_LEVELS)[number];
+/**
+ * Buffer between the Vercel function timeout and the agent turn timeout so
+ * Junior can abort, persist, and schedule continuation before host teardown.
+ */
+export declare const FUNCTION_TIMEOUT_BUFFER_SECONDS = 20;
 export interface BotConfig {
     advisor: AdvisorConfig;
     fastModelId: string;

package/dist/chat/credentials/broker.d.ts

@@ -1,3 +1,4 @@
+import type { CredentialContext } from "@/chat/credentials/context";
 export declare class CredentialUnavailableError extends Error {
     readonly provider: string;
     constructor(provider: string, message: string);
@@ -16,7 +17,7 @@ export interface CredentialLease {
 }
 export interface CredentialBroker {
     issue(input: {
+        context: CredentialContext;
         reason: string;
-        requesterId?: string;
     }): Promise<CredentialLease>;
 }

package/dist/chat/credentials/context.d.ts

@@ -0,0 +1,28 @@
+import type { AgentPluginCredentialSubject } from "@sentry/junior-plugin-api";
+export interface CredentialSubjectBinding {
+    type: "slack-direct-conversation";
+    teamId: string;
+    channelId: string;
+    signature: string;
+}
+export type CredentialSystemActor = {
+    type: "system";
+    id: string;
+};
+export type CredentialSubject = AgentPluginCredentialSubject & {
+    binding: CredentialSubjectBinding;
+};
+export type CredentialContext = {
+    actor: {
+        type: "user";
+        userId: string;
+    };
+    subject?: never;
+} | {
+    actor: CredentialSystemActor;
+    subject?: CredentialSubject;
+};
+/** Return the user whose OAuth token may satisfy this credential request. */
+export declare function credentialUserSubjectId(context: CredentialContext): string | undefined;
+/** Parse an untrusted credential context payload from sandbox egress state. */
+export declare function parseCredentialContext(value: unknown): CredentialContext | undefined;

package/dist/chat/credentials/subject.d.ts

@@ -0,0 +1,20 @@
+import type { AgentPluginCredentialSubject } from "@sentry/junior-plugin-api";
+import type { CredentialSubject } from "@/chat/credentials/context";
+/** Create a delegated user credential subject for a verified Slack DM turn. */
+export declare function createSlackDirectCredentialSubject(input: {
+    channelId: string | undefined;
+    teamId: string | undefined;
+    userId: string | undefined;
+}): AgentPluginCredentialSubject | undefined;
+/** Bind a delegated user subject to the Slack DM destination being dispatched. */
+export declare function bindSlackDirectCredentialSubject(input: {
+    channelId: string;
+    subject: AgentPluginCredentialSubject;
+    teamId: string;
+}): CredentialSubject | undefined;
+/** Verify that a delegated subject was signed for the dispatch destination. */
+export declare function verifySlackDirectCredentialSubject(input: {
+    channelId: string;
+    subject: CredentialSubject;
+    teamId: string;
+}): boolean;

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

@@ -0,0 +1,19 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { type StateAdapter } from "chat";
+import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+import type { WaitUntilFn } from "@/handlers/types";
+export interface SlackWebhookServices {
+    getUserTokenStore?: () => UserTokenStore;
+    getSlackAdapter: () => SlackAdapter;
+    queue: ConversationWorkQueue;
+    runtime: Pick<SlackTurnRuntime<unknown>, "handleAssistantContextChanged" | "handleAssistantThreadStarted" | "handleNewMention" | "handleSubscribedMessage">;
+    state?: StateAdapter;
+}
+/** Handle Slack webhooks by enqueueing durable conversation work. */
+export declare function handleSlackWebhook(args: {
+    request: Request;
+    services: SlackWebhookServices;
+    waitUntil: WaitUntilFn;
+}): Promise<Response>;

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

@@ -1,4 +1,4 @@
-/** Thrown when an MCP tool returns an error result. */
+/** Thrown when an MCP failure should be returned as a model-visible tool error. */
 export declare class McpToolError extends Error {
     constructor(message: string);
 }

package/dist/chat/plugins/github-permissions.d.ts

@@ -0,0 +1,11 @@
+type GitHubPermissionRequest = Record<string, "read" | "write">;
+export declare const DEFAULT_GITHUB_SYSTEM_READ_SCOPES: Set<string>;
+/** Validate and normalize GitHub App read scopes from plugin configuration. */
+export declare function normalizeGitHubSystemReadPermissionScopes(scopes: string[], context: string): string[];
+/** Convert plugin capabilities into the GitHub App installation permission body. */
+export declare function githubCapabilitiesToPermissions(capabilities: string[], pluginName: string): GitHubPermissionRequest;
+/** Convert configured system scopes into read-only GitHub App permissions. */
+export declare function githubSystemReadPermissionsFromScopes(scopes: string[]): GitHubPermissionRequest;
+/** Intersect installation permissions with the allowed system read scope set. */
+export declare function githubInstallationReadPermissions(permissions: Record<string, string> | undefined, allowedScopes: Set<string>): GitHubPermissionRequest;
+export {};

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

@@ -28,6 +28,7 @@ export interface GitHubAppCredentials {
     appIdEnv: string;
     privateKeyEnv: string;
     installationIdEnv: string;
+    systemReadPermissions?: string[];
 }
 export type PluginCredentials = OAuthBearerCredentials | GitHubAppCredentials;
 export interface PluginNpmRuntimeDependency {
@@ -115,6 +116,7 @@ export interface PluginManifestConfig {
         appIdEnv?: string;
         privateKeyEnv?: string;
         installationIdEnv?: string;
+        systemReadPermissions?: string[];
     } | null;
     runtimeDependencies?: PluginRuntimeDependencyConfig[] | null;
     runtimePostinstall?: PluginRuntimePostinstallCommand[] | null;

package/dist/chat/prompt.d.ts

@@ -1,3 +1,4 @@
+import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { SkillMetadata, SkillInvocation } from "@/chat/skills";
 import type { ActiveMcpCatalogSummary } from "@/chat/tools/skill/mcp-tool-summary";
@@ -15,6 +16,7 @@ type TurnContextPromptInput = {
     toolGuidance?: ToolPromptContext[];
     runtime?: {
         conversationId?: string;
+        slackConversation?: SlackConversationContext;
     };
     invocation: SkillInvocation | null;
     requester?: {

package/dist/chat/respond-helpers.d.ts

@@ -63,8 +63,10 @@ export declare function isToolResultError(result: unknown): boolean;
 export declare function isAssistantMessage(value: unknown): value is AssistantMessage;
 /** Extract role string from a raw Pi message. */
 export declare function getPiMessageRole(value: unknown): string | undefined;
-/** Refresh volatile runtime context in session history before continuing Pi. */
-export declare function refreshRuntimeTurnContext(messages: PiMessage[], turnContextPrompt: string): PiMessage[];
+/**
+ * Add bootstrap context only for stored boundaries captured before prompt().
+ */
+export declare function prependMissingRuntimeTurnContext(messages: PiMessage[], turnContextPrompt: string): PiMessage[];
 /** Return whether Pi history already carries session bootstrap context. */
 export declare function hasRuntimeTurnContext(messages: PiMessage[]): boolean;
 /** Remove volatile runtime context before reusing messages as history. */

package/dist/chat/respond.d.ts

@@ -5,22 +5,21 @@ import type { ImageGenerateToolDeps, WebFetchToolDeps, WebSearchToolDeps } from
 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 { SlackConversationContext } from "@/chat/slack/conversation-context";
 import { type AssistantReply, type AgentTurnDiagnostics } from "@/chat/services/turn-result";
+import type { CredentialContext } from "@/chat/credentials/context";
 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";
-    };
+    credentialContext?: CredentialContext;
     requester?: {
         userId?: string;
         userName?: string;
         fullName?: string;
         email?: string;
     };
+    slackConversation?: SlackConversationContext;
     correlation?: {
         conversationId?: string;
         threadId?: string;
@@ -32,8 +31,6 @@ export interface ReplyRequestContext {
         messageTs?: string;
         threadTs?: string;
         requesterId?: string;
-        actorType?: string;
-        actorId?: string;
     };
     toolChannelId?: string;
     conversationContext?: string;
@@ -43,13 +40,10 @@ export interface ReplyRequestContext {
     configuration?: Record<string, unknown>;
     /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
     piMessages?: PiMessage[];
+    /** Absolute wall-clock deadline for this host request, in milliseconds. */
+    turnDeadlineAtMs?: number;
     channelConfiguration?: ChannelConfigurationService;
-    userAttachments?: Array<{
-        data?: Buffer;
-        mediaType: string;
-        filename?: string;
-        promptText?: string;
-    }>;
+    userAttachments?: ReplyRequestAttachment[];
     inboundAttachmentCount?: number;
     omittedImageAttachmentCount?: number;
     sandbox?: {
@@ -58,12 +52,16 @@ export interface ReplyRequestContext {
     };
     onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
     onArtifactStateUpdated?: (artifactState: ThreadArtifactsState) => void | Promise<void>;
+    onInputCommitted?: () => void | Promise<void>;
     toolOverrides?: {
         imageGenerate?: ImageGenerateToolDeps;
         webFetch?: WebFetchToolDeps;
         webSearch?: WebSearchToolDeps;
     };
     onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
+    drainSteeringMessages?: (inject: (messages: ReplySteeringMessage[]) => Promise<void>) => Promise<ReplySteeringMessage[]>;
+    /** Return true when the durable worker should pause at the next Pi boundary. */
+    shouldYield?: () => boolean;
     onAuthPending?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     onTextDelta?: (deltaText: string) => void | Promise<void>;
     onAssistantMessageStart?: () => void | Promise<void>;
@@ -72,5 +70,17 @@ export interface ReplyRequestContext {
         params: Record<string, unknown>;
     }) => void;
 }
+export interface ReplyRequestAttachment {
+    data?: Buffer;
+    mediaType: string;
+    filename?: string;
+    promptText?: string;
+}
+export interface ReplySteeringMessage {
+    omittedImageAttachmentCount?: number;
+    text: string;
+    timestampMs?: number;
+    userAttachments?: ReplyRequestAttachment[];
+}
 /** Run a full agent turn: discover skills, execute tools, and return the assistant reply. */
 export declare function generateAssistantReply(messageText: string, context?: ReplyRequestContext): Promise<AssistantReply>;

package/dist/chat/runtime/processing-reaction.d.ts

@@ -2,6 +2,7 @@ import type { Message, Thread } from "chat";
 import type { TurnToolInvocation } from "@/chat/runtime/turn-input";
 /** Controls the automatic Slack processing reaction lifecycle for one message. */
 export interface ProcessingReactionSession {
+    complete: () => Promise<void>;
     keep: () => void;
     stop: () => Promise<void>;
 }

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

@@ -48,8 +48,13 @@ interface ReplyExecutorDeps {
 export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options?: {
     beforeFirstResponsePost?: () => Promise<void>;
     explicitMention?: boolean;
+    onInputCommitted?: () => Promise<void>;
     onToolInvocation?: (invocation: TurnToolInvocation) => void;
+    onTurnCompleted?: () => Promise<void>;
+    onTurnStatePersisted?: () => Promise<void>;
     preparedState?: PreparedTurnState;
     queuedMessages?: QueuedTurnMessage[];
+    drainSteeringMessages?: (inject: (messages: QueuedTurnMessage[]) => Promise<void>) => Promise<QueuedTurnMessage[]>;
+    shouldYield?: () => boolean;
 }) => Promise<void>;
 export {};

package/dist/chat/runtime/request-deadline.d.ts

@@ -0,0 +1,8 @@
+export interface TurnRequestDeadline {
+    deadlineAtMs: number;
+    startedAtMs: number;
+}
+/** Return the host request deadline inherited by the current async turn. */
+export declare function getTurnRequestDeadline(): TurnRequestDeadline | undefined;
+/** Run work with one host request deadline shared by nested queued turns. */
+export declare function runWithTurnRequestDeadline<T>(callback: () => T, startedAtMs?: number): T;

package/dist/chat/runtime/slack-resume.d.ts

@@ -23,12 +23,11 @@ interface ResumeSlackTurnArgs {
 /**
  * Resume a paused Slack turn under the normal thread lock.
  *
- * Success is defined by final reply delivery, not only by successful assistant
- * generation. If the final visible Slack post fails, the resumed turn is
- * treated as failed so thread state does not claim the user saw a reply that
- * never arrived.
+ * Started resumes own their terminal side effects: final delivery, pause
+ * persistence, or failure response. Returns false only when `beforeStart`
+ * proves the resume is stale before generation begins.
  */
-export declare function resumeSlackTurn(args: ResumeSlackTurnArgs): Promise<void>;
+export declare function resumeSlackTurn(args: ResumeSlackTurnArgs): Promise<boolean>;
 /** Resume an OAuth-paused Slack request through the shared resume runner. */
 export declare function resumeAuthorizedRequest(args: {
     messageText: string;

package/dist/chat/runtime/slack-runtime.d.ts

@@ -20,8 +20,12 @@ export interface AssistantLifecycleEvent {
 }
 export interface ReplyHooks {
     beforeFirstResponsePost?: () => Promise<void>;
+    drainSteeringMessages?: (inject: (messages: Message[]) => Promise<void>) => Promise<Message[]>;
     messageContext?: MessageContext;
+    onInputCommitted?: () => Promise<void>;
     onToolInvocation?: (invocation: TurnToolInvocation) => void;
+    onTurnStatePersisted?: () => Promise<void>;
+    shouldYield?: () => boolean;
 }
 export interface SlackTurnRuntimeDependencies<TPreparedState> {
     assistantUserName: string;
@@ -67,12 +71,18 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
     replyToThread: (thread: Thread, message: Message, options?: {
         beforeFirstResponsePost?: () => Promise<void>;
         explicitMention?: boolean;
+        onInputCommitted?: () => Promise<void>;
         onToolInvocation?: (invocation: TurnToolInvocation) => void;
+        onTurnCompleted?: () => Promise<void>;
+        onTurnStatePersisted?: () => Promise<void>;
         preparedState?: TPreparedState;
         queuedMessages?: QueuedTurnMessage[];
+        drainSteeringMessages?: (inject: (messages: QueuedTurnMessage[]) => Promise<void>) => Promise<QueuedTurnMessage[]>;
+        shouldYield?: () => boolean;
     }) => Promise<void>;
     decideSubscribedReply: SubscribedReplyPolicy;
     stripLeadingBotMention: (text: string, options: {
+        botUserId?: string;
         stripLeadingSlackMentionToken?: boolean;
     }) => string;
     withSpan: (name: string, op: string, context: Record<string, unknown>, callback: () => Promise<void>) => Promise<void>;

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

@@ -1,7 +1,9 @@
 import type { Message, Thread } from "chat";
-export declare function stripLeadingBotMention(text: string, options?: {
+interface StripLeadingBotMentionOptions {
+    botUserId?: string;
     stripLeadingSlackMentionToken?: boolean;
-}): string;
+}
+export declare function stripLeadingBotMention(text: string, options?: StripLeadingBotMentionOptions): string;
 export declare function getThreadId(thread: Thread, _message: Message): string | undefined;
 export declare function getRunId(thread: Thread, message: Message): string | undefined;
 export declare function getChannelId(thread: Thread, message: Message): string | undefined;
@@ -22,3 +24,4 @@ export declare function getAssistantThreadContext(message: Message): {
 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;
+export {};

package/dist/chat/runtime/timeout-resume-runner.d.ts

@@ -0,0 +1,19 @@
+import { type TurnContinuationRequest } from "@/chat/services/timeout-resume";
+/** Runtime ports for timeout continuation scheduling. */
+export interface TimeoutResumeRunnerOptions {
+    scheduleTurnTimeoutResume?: (request: TurnContinuationRequest) => Promise<void>;
+}
+/**
+ * Resume one durable timeout continuation for a Slack thread.
+ *
+ * Returns false when the session became stale before generation began.
+ */
+export declare function resumeTimedOutTurn(payload: TurnContinuationRequest, options?: TimeoutResumeRunnerOptions): Promise<boolean>;
+/**
+ * Retry timeout continuation when the normal Slack thread lock is briefly busy.
+ *
+ * Returns false when the session became stale before generation began. A busy
+ * lock that is rescheduled still returns true because runnable work remains
+ * durable.
+ */
+export declare function resumeTimedOutTurnWithLockRetry(payload: TurnContinuationRequest, options?: TimeoutResumeRunnerOptions): Promise<boolean>;

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

@@ -10,6 +10,7 @@ export interface PreparedTurnState {
     conversationContext?: string;
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
+    userMessageAlreadyReplied?: boolean;
     userMessageId?: string;
 }
 export interface PrepareTurnStateDeps {

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

@@ -24,6 +24,19 @@ export declare class RetryableTurnError extends Error {
     constructor(reason: RetryableTurnReason, message: string, metadata?: RetryableTurnMetadata);
 }
 export declare function isRetryableTurnError(error: unknown, reason?: RetryableTurnReason): error is RetryableTurnError;
+/** Error indicating the turn paused voluntarily at a safe continuation boundary. */
+export declare class CooperativeTurnYieldError extends Error {
+    readonly code = "cooperative_turn_yield";
+    constructor(message?: string);
+}
+export declare function isCooperativeTurnYieldError(error: unknown): error is CooperativeTurnYieldError;
+/** Error indicating durable turn input could not be committed by the worker owner. */
+export declare class TurnInputCommitLostError extends Error {
+    readonly code = "turn_input_commit_lost";
+    constructor(message?: string);
+}
+/** Return whether an error means the durable worker lost input ownership. */
+export declare function isTurnInputCommitLostError(error: unknown): error is TurnInputCommitLostError;
 /** Mark a turn as the active turn in conversation state. */
 export declare function startActiveTurn(args: {
     conversation: ThreadConversationState;

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

@@ -5,7 +5,7 @@ export declare function matchesSandboxEgressDomain(host: string, domain: string)
 export declare function resolveSandboxEgressProviderForHost(host: string): string | undefined;
 /** Build the policy that forwards provider requests back to Junior for credentials. */
 export declare function buildSandboxEgressNetworkPolicy(input?: {
-    requesterToken?: string;
+    credentialToken?: string;
 }): NetworkPolicy;
 /** Resolve non-secret command environment values for registered sandbox providers. */
 export declare function resolveSandboxCommandEnvironment(): Promise<Record<string, string>>;

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

@@ -1,7 +1,8 @@
+import { type CredentialContext } from "@/chat/credentials/context";
 import type { CredentialHeaderTransform } from "@/chat/credentials/broker";
 export declare const SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
-export interface SandboxEgressRequesterContext {
-    requesterId: string;
+export interface SandboxEgressCredentialContext {
+    credentials: CredentialContext;
     egressId: string;
     expiresAtMs: number;
     contextId: string;
@@ -11,17 +12,17 @@ export interface SandboxEgressCredentialLease {
     expiresAt: string;
     headerTransforms: CredentialHeaderTransform[];
 }
-/** Create a signed requester/sandbox context token for lazy sandbox egress auth. */
-export declare function createSandboxEgressRequesterToken(input: {
-    requesterId: string;
+/** Create a signed actor/sandbox context token for lazy sandbox egress auth. */
+export declare function createSandboxEgressCredentialToken(input: {
+    credentials: CredentialContext;
     egressId: string;
     ttlMs?: number;
 }): string;
-/** Verify a signed requester/sandbox context token from the proxy URL. */
-export declare function parseSandboxEgressRequesterToken(token: string | undefined): SandboxEgressRequesterContext | undefined;
-/** Cache a short-lived credential lease for repeated forwarded requests for one requester/sandbox context. */
-export declare function setSandboxEgressCredentialLease(context: SandboxEgressRequesterContext, lease: SandboxEgressCredentialLease): Promise<void>;
-/** Load a cached egress credential lease for a requester/sandbox context/provider pair. */
-export declare function getSandboxEgressCredentialLease(provider: string, context: SandboxEgressRequesterContext): Promise<SandboxEgressCredentialLease | undefined>;
+/** Verify a signed actor/sandbox context token from the proxy URL. */
+export declare function parseSandboxEgressCredentialToken(token: string | undefined): SandboxEgressCredentialContext | undefined;
+/** Cache a short-lived credential lease for repeated forwarded requests for one actor/sandbox context. */
+export declare function setSandboxEgressCredentialLease(context: SandboxEgressCredentialContext, lease: SandboxEgressCredentialLease): Promise<void>;
+/** Load a cached egress credential lease for an actor/sandbox context/provider pair. */
+export declare function getSandboxEgressCredentialLease(provider: string, context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
 /** Clear a cached egress credential lease after the provider rejects its headers. */
-export declare function clearSandboxEgressCredentialLease(provider: string, context: SandboxEgressRequesterContext): Promise<void>;
+export declare function clearSandboxEgressCredentialLease(provider: string, context: SandboxEgressCredentialContext): Promise<void>;

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

@@ -1,4 +1,5 @@
 import { type LogContext } from "@/chat/logging";
+import type { CredentialContext } from "@/chat/credentials/context";
 import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
@@ -42,9 +43,7 @@ export declare function createSandboxExecutor(options?: {
     sandboxDependencyProfileHash?: string;
     timeoutMs?: number;
     traceContext?: LogContext;
-    credentialEgress?: {
-        requesterId: string;
-    };
+    credentialEgress?: CredentialContext;
     agentHooks?: AgentPluginHookRunner;
     onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
     runBashCustomCommand?: (command: string) => Promise<{

package/dist/chat/services/timeout-resume.d.ts

@@ -1,16 +1,21 @@
+import type { StateAdapter } from "chat";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 export interface TurnContinuationRequest {
     conversationId: string;
     expectedVersion: number;
     sessionId: string;
 }
-/** Bound automatic timeout continuation so one bad turn cannot loop forever. */
-export declare function canScheduleTurnTimeoutResume(nextSliceId: number | undefined): boolean;
+export interface ScheduleTurnTimeoutResumeOptions {
+    nowMs?: number;
+    queue?: ConversationWorkQueue;
+    state?: StateAdapter;
+}
 /** Build the callback request for an awaiting automatic turn continuation. */
 export declare function getAwaitingTurnContinuationRequest(args: {
     conversationId: string;
     sessionId: string;
 }): Promise<TurnContinuationRequest | undefined>;
-/** Schedule an authenticated internal callback to resume a timed-out turn. */
-export declare function scheduleTurnTimeoutResume(request: TurnContinuationRequest): Promise<void>;
+/** Schedule durable conversation work to resume a timed-out turn. */
+export declare function scheduleTurnTimeoutResume(request: TurnContinuationRequest, options?: ScheduleTurnTimeoutResumeOptions): Promise<void>;
 /** Verify and parse an authenticated timeout resume callback request. */
 export declare function verifyTurnTimeoutResumeRequest(request: Request): Promise<TurnContinuationRequest | undefined>;