@sentry/junior 0.109.0 → 0.111.0

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

@@ -1,60 +1,33 @@
 import { type LogContext } from "@/chat/logging";
-import { type SandboxEgressAuthRequiredSignal, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/session";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { CredentialContext } from "@/chat/credentials/context";
-import type { PluginHookRunner } from "@/chat/plugins/agent-hooks";
-import type { SandboxInstance } from "@/chat/sandbox/workspace";
+import type { SandboxRef } from "@/chat/sandbox/ref";
+import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
-interface SandboxExecutionInput {
+export interface SandboxToolCall {
     toolName: string;
     input: unknown;
     signal?: AbortSignal;
 }
-export interface SandboxExecutionEnvelope<T = unknown> {
-    result: T;
+export interface SandboxTools {
+    supports(toolName: string): boolean;
+    execute(params: SandboxToolCall): Promise<unknown>;
 }
-export interface BashCustomCommandResult {
-    ok: boolean;
-    command: string;
-    cwd: string;
-    exit_code: number;
-    signal: null;
-    timed_out: boolean;
-    aborted?: boolean;
-    stdout: string;
-    stderr: string;
-    stdout_truncated: boolean;
-    stderr_truncated: boolean;
-    auth_required?: SandboxEgressAuthRequiredSignal;
-    permission_denied?: SandboxEgressPermissionDeniedSignal;
+export interface SandboxAccess {
+    readonly tools: SandboxTools;
+    readonly workspace: SandboxWorkspace;
+    sandboxRef(): SandboxRef | undefined;
 }
-export interface SandboxAcquiredState {
-    sandboxId: string;
-    sandboxDependencyProfileHash?: string;
-}
-export interface SandboxExecutor {
-    configureSkills(skills: SkillMetadata[]): void;
-    configureReferenceFiles(files: string[]): void;
-    getSandboxId(): string | undefined;
-    getDependencyProfileHash(): string | undefined;
-    canExecute(toolName: string): boolean;
-    createSandbox(): Promise<SandboxInstance>;
-    execute<T>(params: SandboxExecutionInput): Promise<SandboxExecutionEnvelope<T>>;
-    dispose(): Promise<void>;
-}
-/** Create one sandbox-backed tool executor facade for the current turn. */
-export declare function createSandboxExecutor(options?: {
-    sandboxId?: string;
-    sandboxDependencyProfileHash?: string;
+export interface SandboxOptions {
+    sandboxRef?: SandboxRef;
+    skills: SkillMetadata[];
+    referenceFiles: string[];
     timeoutMs?: number;
     traceContext?: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;
-    agentHooks?: PluginHookRunner;
-    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
-    runBashCustomCommand?: (command: string) => Promise<{
-        handled: boolean;
-        result?: BashCustomCommandResult;
-    }>;
-}): SandboxExecutor;
-export {};
+    prepare?: (workspace: SandboxWorkspace) => void | Promise<void>;
+    onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
+}
+/** Create lazy run-scoped access to a conversation's durable sandbox. */
+export declare function createSandbox(options: SandboxOptions): SandboxAccess;

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

@@ -1,8 +1,10 @@
 import { type NetworkPolicy } from "@vercel/sandbox";
 import { type LogContext, type TracePropagationHeaders } from "@/chat/logging";
-import { type SandboxFileSystem, type SandboxInstance } from "@/chat/sandbox/workspace";
+import { type SandboxFileSystem, type SandboxSession } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
+import type { SandboxRef } from "@/chat/sandbox/ref";
 interface SandboxToolExecutors {
+    sessionId: string;
     bash: (input: {
         command: string;
         env?: Record<string, string>;
@@ -30,29 +32,23 @@ interface SandboxToolExecutors {
     }>;
     fs: SandboxFileSystem;
 }
-interface SandboxSessionManager {
-    configureSkills(skills: SkillMetadata[]): void;
-    configureReferenceFiles(files: string[]): void;
-    getSandboxId(): string | undefined;
-    getSandboxEgressId(): string | undefined;
-    getDependencyProfileHash(): string | undefined;
-    createSandbox(): Promise<SandboxInstance>;
-    ensureToolExecutors(): Promise<SandboxToolExecutors>;
+interface SandboxRuntime {
+    sandboxRef(): SandboxRef | undefined;
+    acquire(): Promise<SandboxSession>;
+    tools(): Promise<SandboxToolExecutors>;
     refreshNetworkPolicy(traceHeaders?: TracePropagationHeaders): Promise<void>;
-    dispose(): Promise<void>;
 }
-/** Manage sandbox lifecycle, sync, keepalive, and tool executor caching for one executor instance. */
-export declare function createSandboxSessionManager(options?: {
-    sandboxId?: string;
-    sandboxDependencyProfileHash?: string;
+interface SandboxRuntimeOptions {
+    sandboxRef?: SandboxRef;
+    skills: SkillMetadata[];
+    referenceFiles: string[];
     timeoutMs?: number;
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string, traceHeaders?: TracePropagationHeaders) => NetworkPolicy | undefined;
-    onSandboxPrepare?: (sandbox: SandboxInstance) => void | Promise<void>;
-    onSandboxAcquired?: (sandbox: {
-        sandboxId: string;
-        sandboxDependencyProfileHash?: string;
-    }) => void | Promise<void>;
-}): SandboxSessionManager;
+    onSandboxPrepare?: (sandbox: SandboxSession) => void | Promise<void>;
+    onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
+}
+/** Own sandbox acquisition, preparation, and session-scoped tool caching. */
+export declare function createSandboxRuntime(options: SandboxRuntimeOptions): SandboxRuntime;
 export {};

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

@@ -1,4 +1,4 @@
-import type { SandboxInstance } from "@/chat/sandbox/workspace";
+import type { SandboxSession } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
 /** Resolve a virtual sandbox skill path back to the host filesystem when no sandbox exists yet. */
 export declare function resolveHostSkillPath(availableSkills: SkillMetadata[], sandboxPath: string): string | null;
@@ -8,7 +8,7 @@ export declare function resolveHostDataPath(referenceFiles: string[], sandboxPat
 export declare function isHostFileMissingError(error: unknown): boolean;
 /** Copy the current skill set and reference files into a sandbox. */
 export declare function syncSkillsToSandbox(params: {
-    sandbox: SandboxInstance;
+    sandbox: SandboxSession;
     skills: SkillMetadata[];
     referenceFiles?: string[];
     withSpan: <T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>) => Promise<T>;

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

@@ -1,8 +1,8 @@
-import type { NetworkPolicy, Sandbox as VercelSandbox } from "@vercel/sandbox";
+import { type NetworkPolicy, type Sandbox as VercelSandbox } from "@vercel/sandbox";
 export interface SandboxCommandResult {
     exitCode: number;
-    stderr(): Promise<string>;
-    stdout(): Promise<string>;
+    stderr: string;
+    stdout: string;
 }
 export interface SandboxCommandInput {
     args?: string[];
@@ -31,10 +31,15 @@ export interface SandboxWorkspace {
         path: string;
     }): Promise<Buffer | null | undefined>;
     runCommand(input: SandboxCommandInput): Promise<SandboxCommandResult>;
+    writeFiles(files: Array<{
+        content: string | Uint8Array;
+        mode?: number;
+        path: string;
+    }>): Promise<void>;
 }
-export interface SandboxInstance extends SandboxWorkspace {
+export interface SandboxSession extends SandboxWorkspace {
     readonly sandboxId: string;
-    readonly sandboxEgressId: string;
+    readonly sessionId: string;
     readonly fs: SandboxFileSystem;
     extendTimeout(duration: number): Promise<void>;
     mkDir(path: string): Promise<void>;
@@ -45,11 +50,8 @@ export interface SandboxInstance extends SandboxWorkspace {
     update(params: {
         networkPolicy?: NetworkPolicy;
     }): Promise<void>;
-    writeFiles(files: Array<{
-        content: string | Uint8Array;
-        mode?: number;
-        path: string;
-    }>): Promise<void>;
 }
-/** Adapt the Vercel SDK object once so the rest of Junior sees one sandbox contract. */
-export declare function createSandboxInstance(sandbox: VercelSandbox): SandboxInstance;
+/** Pin Junior's sandbox contract to one Vercel session without SDK replay. */
+export declare function createSandboxSession(sandbox: VercelSandbox, options?: {
+    onUnavailable?: (sessionId: string) => void;
+}): SandboxSession;

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

@@ -12,6 +12,10 @@ export declare class AuthorizationPauseError extends Error {
     readonly providerDisplayName: string;
     constructor(kind: AuthorizationPauseKind, provider: string, providerDisplayName: string, disposition: AuthorizationPauseDisposition);
 }
+/** Error indicating an authorization pause could not be made durable. */
+export declare class AuthPausePersistenceError extends Error {
+    constructor(conversationId: string, turnId: string, cause?: unknown);
+}
 /** Error indicating this turn cannot start an external authorization flow. */
 export declare class AuthorizationFlowDisabledError extends Error {
     readonly kind: AuthorizationPauseKind;

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

@@ -38,6 +38,7 @@ interface HandoffContextArgs {
     target: {
         modelId: string;
         modelProfile: ModelProfile;
+        reasoningLevel?: string;
     };
 }
 /** Build retained user messages for a compacted Pi replacement history. */

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

@@ -3,6 +3,7 @@ import type { PiMessage } from "@/chat/pi/messages";
 import type { TurnRoute } from "@/chat/services/turn-router";
 import type { AgentTurnUsage } from "@/chat/usage";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { SandboxRef } from "@/chat/sandbox/ref";
 import { extractAssistantText } from "@/chat/pi/transcript";
 export interface AgentTurnDiagnostics {
     assistantMessageCount: number;
@@ -23,8 +24,7 @@ export interface AgentRunResult {
     /** Sanitized terminal text for diagnostics and failure fallback, not success delivery. */
     text: string;
     artifactStatePatch?: Partial<ThreadArtifactsState>;
-    sandboxId?: string;
-    sandboxDependencyProfileHash?: string;
+    sandboxRef?: SandboxRef;
     piMessages?: PiMessage[];
     diagnostics: AgentTurnDiagnostics;
 }
@@ -33,8 +33,7 @@ export interface TurnResultInput {
     userInput: string;
     artifactStatePatch: Partial<ThreadArtifactsState>;
     toolCalls: string[];
-    sandboxId?: string;
-    sandboxDependencyProfileHash?: string;
+    sandboxRef?: SandboxRef;
     piMessages?: PiMessage[];
     durationMs?: number;
     generatedFileCount: number;

package/dist/chat/task-execution/queue-signing.d.ts

@@ -1,11 +1,13 @@
-import type { ConversationQueueMessage } from "./queue";
-declare const CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION = "v1";
+import { z } from "zod";
+import { type ConversationQueueMessage } from "./queue";
 export declare const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS: number;
-interface SignedConversationQueueMessage extends ConversationQueueMessage {
-    signature: string;
-    signatureVersion: typeof CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION;
-    signedAtMs: number;
-}
+declare const signedConversationQueueMessageSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    signature: z.ZodString;
+    signatureVersion: z.ZodLiteral<"v2">;
+    signedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+type SignedConversationQueueMessage = z.output<typeof signedConversationQueueMessageSchema>;
 export type ConversationQueueMessageVerificationResult = {
     message: ConversationQueueMessage;
     status: "verified";
@@ -18,7 +20,7 @@ export type ConversationQueueMessageVerificationResult = {
 };
 /** Sign a conversation queue payload before it crosses the public callback route. */
 export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): SignedConversationQueueMessage;
-/** Explain whether a queue payload is verified, rejected, or temporarily unverifiable. */
+/** Explain whether a queue payload is verified, rejected, or unavailable. */
 export declare function verifyConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessageVerificationResult;
 /** Verify a signed conversation queue payload from the Vercel Queue callback. */
 export declare function verifySignedConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessage | undefined;

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

@@ -1,9 +1,11 @@
-import type { Destination } from "@sentry/junior-plugin-api";
-export interface ConversationQueueMessage {
-    conversationId: string;
-    destination: Destination;
-}
-export type ConversationQueueMessageRejectReason = "destination_mismatch" | "expired" | "invalid_record" | "malformed" | "signature_mismatch";
+import { z } from "zod";
+/** Validate the conversation work hint sent through Vercel Queue. */
+export declare const conversationQueueMessageSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+}, z.core.$strict>;
+/** Conversation work hint accepted by the queue callback and worker. */
+export type ConversationQueueMessage = z.output<typeof conversationQueueMessageSchema>;
+export type ConversationQueueMessageRejectReason = "expired" | "invalid_record" | "malformed" | "signature_mismatch";
 export declare class ConversationQueueMessageRejectedError extends Error {
     conversationId?: string;
     reason: ConversationQueueMessageRejectReason;
@@ -11,7 +13,7 @@ export declare class ConversationQueueMessageRejectedError extends Error {
         conversationId?: string;
     });
 }
-/** Return whether a queue payload was permanently rejected at the message boundary. */
+/** Return whether an error means the queue message was permanently rejected. */
 export declare function isConversationQueueMessageRejectedError(error: unknown): error is ConversationQueueMessageRejectedError;
 export interface ConversationQueueSendOptions {
     delayMs?: number;

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

@@ -22,8 +22,8 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         _type: z.ZodLiteral<"chat:Message">;
         attachments: z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
-                image: "image";
                 file: "file";
+                image: "image";
                 audio: "audio";
                 video: "video";
             }>;
@@ -72,16 +72,16 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         channelId: z.ZodString;
         channelVisibility: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            private: "private";
             external: "external";
+            private: "private";
             workspace: "workspace";
         }>>;
         currentMessage: z.ZodOptional<z.ZodObject<{
             _type: z.ZodLiteral<"chat:Message">;
             attachments: z.ZodArray<z.ZodObject<{
                 type: z.ZodEnum<{
-                    image: "image";
                     file: "file";
+                    image: "image";
                     audio: "audio";
                     video: "video";
                 }>;
@@ -132,8 +132,8 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         _type: z.ZodLiteral<"chat:Message">;
         attachments: z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
-                image: "image";
                 file: "file";
+                image: "image";
                 audio: "audio";
                 video: "video";
             }>;
@@ -182,16 +182,16 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         channelId: z.ZodString;
         channelVisibility: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            private: "private";
             external: "external";
+            private: "private";
             workspace: "workspace";
         }>>;
         currentMessage: z.ZodOptional<z.ZodObject<{
             _type: z.ZodLiteral<"chat:Message">;
             attachments: z.ZodArray<z.ZodObject<{
                 type: z.ZodEnum<{
-                    image: "image";
                     file: "file";
+                    image: "image";
                     audio: "audio";
                     video: "video";
                 }>;
@@ -272,7 +272,9 @@ interface SlackResourceEventInboundInput {
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
-    resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
+    resumeAwaitingContinuation: (conversationId: string, options: {
+        shouldYield: () => boolean;
+    }) => Promise<boolean>;
     conversationStore?: ConversationStore;
     runtime: SlackInboxTurnRuntime;
     state?: StateAdapter;

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

@@ -1,5 +1,6 @@
 import type { StateAdapter } from "chat";
-import type { Destination } from "@sentry/junior-plugin-api";
+import { type Destination } from "@sentry/junior-plugin-api";
+import { z } from "zod";
 import { type StoredSlackActor } from "@/chat/actor";
 declare class InvalidConversationRecordError extends Error {
     constructor(conversationId: string);
@@ -12,25 +13,67 @@ export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
 export declare const CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
-export type Source = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
+declare const inboundMessageSourceSchema: z.ZodEnum<{
+    slack: "slack";
+    plugin: "plugin";
+    api: "api";
+    local: "local";
+    internal: "internal";
+    resource_event: "resource_event";
+    scheduler: "scheduler";
+}>;
+export type Source = z.output<typeof inboundMessageSourceSchema>;
 export type ExecutionStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
-export interface AgentInput {
-    attachments?: unknown[];
-    authorId?: string;
-    metadata?: Record<string, unknown>;
-    text: string;
-}
-export interface InboundMessage {
-    attemptCount?: number;
-    conversationId: string;
-    createdAtMs: number;
-    destination: Destination;
-    inboundMessageId: string;
-    injectedAtMs?: number;
-    input: AgentInput;
-    receivedAtMs: number;
-    source: Source;
-}
+declare const agentInputSchema: z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    authorId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type AgentInput = z.output<typeof agentInputSchema>;
+/** Durable delivery modes for pending inbound mailbox work. */
+export declare const inboundMessageDeliverySchema: z.ZodEnum<{
+    defer: "defer";
+    interrupt: "interrupt";
+}>;
+export type InboundMessageDelivery = z.output<typeof inboundMessageDeliverySchema>;
+/** Canonical durable mailbox entry owned by task execution. */
+export declare const inboundMessageSchema: z.ZodObject<{
+    attemptCount: z.ZodOptional<z.ZodNumber>;
+    conversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    delivery: z.ZodEnum<{
+        defer: "defer";
+        interrupt: "interrupt";
+    }>;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    inboundMessageId: z.ZodString;
+    injectedAtMs: z.ZodOptional<z.ZodNumber>;
+    input: z.ZodObject<{
+        attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        authorId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        text: z.ZodString;
+    }, z.core.$strict>;
+    receivedAtMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        slack: "slack";
+        plugin: "plugin";
+        api: "api";
+        local: "local";
+        internal: "internal";
+        resource_event: "resource_event";
+        scheduler: "scheduler";
+    }>;
+}, z.core.$strict>;
+export type InboundMessage = z.output<typeof inboundMessageSchema>;
 export interface Lease {
     acquiredAtMs: number;
     expiresAtMs: number;
@@ -56,7 +99,7 @@ export interface Conversation {
     execution: ConversationExecution;
     lastActivityAtMs: number;
     actor?: StoredSlackActor;
-    schemaVersion: 1;
+    schemaVersion: 2;
     source?: Source;
     title?: string;
     updatedAtMs: number;
@@ -182,7 +225,7 @@ export declare function checkInConversationWork(args: {
     state?: StateAdapter;
 }): Promise<boolean>;
 /**
- * Drain pending mailbox entries after the caller acknowledges durable handling.
+ * Resolve pending mailbox entries after the caller accepts responsibility.
  *
  * Returning ids acknowledges only that subset; returning nothing acknowledges
  * every pending entry passed to the handler.
@@ -193,7 +236,10 @@ export declare function drainConversationMailbox(args: {
     leaseToken: string;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<InboundMessage[]>;
+}): Promise<{
+    changed: boolean;
+    messages: InboundMessage[];
+}>;
 /** Acknowledge leased mailbox entries after the handler accepts responsibility. */
 export declare function ackMessages(args: {
     conversationId: string;
@@ -210,6 +256,13 @@ export declare function requestConversationContinuation(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+/** Begin a requested turn resume under the worker's existing lease. */
+export declare function beginConversationResume(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Release the durable execution lease without changing completion state. */
 export declare function releaseConversationWork(args: {
     conversationId: string;

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

@@ -2,13 +2,13 @@ import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "./queue";
 import * as workState from "./state";
-export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
+export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
 import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
 export type EnsureConversationWakeResult = {
     queueMessageId?: string;
     status: "enqueued";
 } | {
-    status: "already_enqueued" | "no_work";
+    status: "already_enqueued" | "lease_active" | "no_work";
 };
 /** Return a persisted conversation record, if one exists. */
 export declare function getConversation(args: {
@@ -94,7 +94,30 @@ export declare function checkInConversationWork(args: {
 export declare function drainConversationMailbox(args: Parameters<typeof workState.drainConversationMailbox>[0] & {
     conversationStore?: ConversationStore;
     state?: StateAdapter;
-}): Promise<workState.InboundMessage[]>;
+}): Promise<{
+    conversationId: string;
+    createdAtMs: number;
+    delivery: "defer" | "interrupt";
+    destination: {
+        platform: "slack";
+        teamId: string;
+        channelId: string;
+    } | {
+        platform: "local";
+        conversationId: string;
+    };
+    inboundMessageId: string;
+    input: {
+        text: string;
+        attachments?: unknown[] | undefined;
+        authorId?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    receivedAtMs: number;
+    source: "slack" | "plugin" | "api" | "local" | "internal" | "resource_event" | "scheduler";
+    attemptCount?: number | undefined;
+    injectedAtMs?: number | undefined;
+}[]>;
 /** Acknowledge leased mailbox entries after the handler accepts responsibility. */
 export declare function ackMessages(args: {
     conversationId: string;
@@ -113,6 +136,14 @@ export declare function requestConversationContinuation(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+/** Begin a requested turn resume without releasing the current lease. */
+export declare function beginConversationResume(args: {
+    conversationId: string;
+    leaseToken: string;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Release the durable execution lease without changing completion state. */
 export declare function releaseConversationWork(args: {
     conversationId: string;

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

@@ -4,7 +4,6 @@ import type { ConversationStore } from "@/chat/conversations/store";
 import { type ConversationQueueMessage, type ConversationWorkQueue } from "./queue";
 import { type InboundMessage } from "./store";
 export declare const CONVERSATION_WORK_DEFER_DELAY_MS = 15000;
-export declare const CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 240000;
 export interface ConversationWorkerContext {
     attempt: InboxAttempt;
     checkIn(): Promise<boolean>;

package/dist/chat/tool-support/normalize-result.d.ts

@@ -1,6 +1,6 @@
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-/** Unwrap sandbox envelope and detect structured results. */
-export declare function normalizeToolResult(result: unknown, isSandboxResult: boolean, options?: {
+/** Normalize raw tool output into Pi content and structured details. */
+export declare function normalizeToolResult(result: unknown, options?: {
     requireStructuredResult?: boolean;
     toolName?: string;
 }): {

package/dist/chat/tool-support/pi-tool-adapter.d.ts

@@ -3,10 +3,10 @@ import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import { type LogContext } from "@/chat/logging";
 import type { PluginAuthOrchestration } from "@/chat/services/plugin-auth-orchestration";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
-import type { SandboxExecutor } from "@/chat/sandbox/sandbox";
+import type { SandboxTools } from "@/chat/sandbox/sandbox";
 import type { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
 import type { AnyToolDefinition } from "@/chat/tools/definition";
 import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-report";
 import type { PluginHookRunner } from "@/chat/plugins/agent-hooks";
 /** Wrap tool definitions into Pi Agent tool objects with logging, validation, and sandbox execution. */
-export declare function createPiAgentTools(tools: Record<string, AnyToolDefinition>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolCallId: string, toolName: string, params: Record<string, unknown>) => void | Promise<void>, agentHooks?: PluginHookRunner, conversationPrivacy?: ConversationPrivacy, onToolResult?: (report: ToolExecutionReport) => void | Promise<void>): AgentTool[];
+export declare function createPiAgentTools(tools: Record<string, AnyToolDefinition>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxTools?: SandboxTools, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolCallId: string, toolName: string, params: Record<string, unknown>) => void | Promise<void>, agentHooks?: PluginHookRunner, conversationPrivacy?: ConversationPrivacy, onToolResult?: (report: ToolExecutionReport) => void | Promise<void>): AgentTool[];

package/dist/chat/tool-support/structured-result.d.ts

@@ -61,7 +61,7 @@ export interface JuniorToolResultEnvelope<TDetails extends JuniorToolResult = Ju
 }
 /** Bind continuation metadata to the exposed runtime tool name. */
 export declare function injectContinuationToolName(details: JuniorToolResult, toolName: string): JuniorToolResult | JuniorToolResultWithBoundContinuation;
-interface JuniorTextToolResultEnvelope<TDetails extends JuniorToolResult = JuniorToolResult> {
+export interface JuniorTextToolResultEnvelope<TDetails extends JuniorToolResult = JuniorToolResult> {
     content: [TextContent];
     details: TDetails;
 }
@@ -70,4 +70,3 @@ export declare function makeStructuredToolResult<TDetails extends JuniorToolResu
 export declare function makeStructuredToolResult<TDetails extends JuniorToolResult>(details: TDetails, options: {
     content: Array<TextContent | ImageContent>;
 }): JuniorToolResultEnvelope<TDetails>;
-export {};

package/dist/chat/tools/sandbox/file-uploads.d.ts

@@ -48,5 +48,5 @@ export declare function sandboxArtifactPath(filename: string): string;
 /** Infer upload MIME type from an explicit value or filename extension. */
 export declare function inferMimeType(filename: string, explicitMimeType?: string): string;
 /** Read and validate one sandbox file for Slack/file reply upload. */
-export declare function readSandboxFileUpload(sandbox: SandboxWorkspace, input: SandboxFileMaterializationInput): Promise<SandboxFileUpload>;
+export declare function readSandboxFileUpload(workspace: SandboxWorkspace, input: SandboxFileMaterializationInput): Promise<SandboxFileUpload>;
 export {};