@sentry/junior 0.53.0 → 0.55.0

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

@@ -0,0 +1,28 @@
+import { type Thread } from "chat";
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+import { type ThreadArtifactsState } from "@/chat/state/artifacts";
+export interface ThreadStatePatch {
+    artifacts?: ThreadArtifactsState;
+    conversation?: ThreadConversationState;
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+}
+export interface PersistedSandboxState {
+    sandboxDependencyProfileHash?: string;
+    sandboxId?: string;
+}
+export declare function mergeArtifactsState(artifacts: ThreadArtifactsState, patch: Partial<ThreadArtifactsState> | undefined): ThreadArtifactsState;
+/** Extract persisted sandbox metadata from thread state payload. */
+export declare function getPersistedSandboxState(state: Record<string, unknown>): PersistedSandboxState;
+/** Persist a thread-state patch through the Chat SDK thread interface. */
+export declare function persistThreadState(thread: Thread, patch: ThreadStatePatch): Promise<void>;
+/** Load the persisted state payload for a thread without requiring a Chat singleton. */
+export declare function getPersistedThreadState(threadId: string): Promise<Record<string, unknown>>;
+/** Load the persisted state payload for a channel without constructing a Chat channel. */
+export declare function getPersistedChannelState(channelId: string): Promise<Record<string, unknown>>;
+/** Persist a thread-state patch by thread id without constructing a Chat thread. */
+export declare function persistThreadStateById(threadId: string, patch: ThreadStatePatch): Promise<void>;
+export declare function getChannelConfigurationService(thread: Thread): ChannelConfigurationService;
+/** Resolve a channel configuration service by channel id without a Chat thread. */
+export declare function getChannelConfigurationServiceById(channelId: string): ChannelConfigurationService;

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

@@ -0,0 +1,43 @@
+import type { Message, Thread } from "chat";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+import { type ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+export interface PreparedTurnState {
+    artifacts: ThreadArtifactsState;
+    configuration?: Record<string, unknown>;
+    channelConfiguration?: ChannelConfigurationService;
+    conversation: ThreadConversationState;
+    conversationContext?: string;
+    routingContext?: string;
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    userMessageId?: string;
+}
+export interface PrepareTurnStateDeps {
+    compactConversationIfNeeded: (conversation: ThreadConversationState, context: {
+        threadId?: string;
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+    }) => Promise<void>;
+    hydrateConversationVisionContext: (conversation: ThreadConversationState, context: {
+        threadId?: string;
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadTs?: string;
+    }) => Promise<void>;
+}
+/** Build the turn-state preparer from injected conversation services. */
+export declare function createPrepareTurnState(deps: PrepareTurnStateDeps): (args: {
+    explicitMention: boolean;
+    message: Message;
+    thread: Thread;
+    userText: string;
+    context: {
+        threadId?: string;
+        requesterId?: string;
+        channelId?: string;
+        runId?: string;
+    };
+}) => Promise<PreparedTurnState>;

package/dist/chat/runtime/turn-user-message.d.ts

@@ -0,0 +1,12 @@
+import type { ConversationMessage, ThreadConversationState } from "@/chat/state/conversation";
+/** Return the user message for a persisted turn/session, if one exists. */
+export declare function getTurnUserMessage(conversation: ThreadConversationState, sessionId: string): ConversationMessage | undefined;
+/** Return the persisted user-message id for a turn/session, if one exists. */
+export declare function getTurnUserMessageId(conversation: ThreadConversationState, sessionId: string): string | undefined;
+/** Return the Slack timestamp for the user message that a resumed turn acts on. */
+export declare function getTurnUserSlackMessageTs(message: ConversationMessage | undefined): string | undefined;
+/** Rebuild attachment context for a resumed turn from the persisted user message. */
+export declare function getTurnUserReplyAttachmentContext(message: ConversationMessage | undefined): {
+    inboundAttachmentCount?: number;
+    omittedImageAttachmentCount?: number;
+};

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

@@ -0,0 +1,69 @@
+import type { ThreadConversationState } from "@/chat/state/conversation";
+import type { AuthorizationPauseDisposition, AuthorizationPauseKind } from "@/chat/services/auth-pause";
+import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
+import type { AgentTurnUsage } from "@/chat/usage";
+export { buildDeterministicTurnId } from "@/chat/state/turn-id";
+export type RetryableTurnReason = "mcp_auth_resume" | "plugin_auth_resume" | "turn_timeout_resume";
+export interface RetryableTurnMetadata {
+    authDisposition?: AuthorizationPauseDisposition;
+    authDurationMs?: number;
+    authKind?: AuthorizationPauseKind;
+    authProvider?: string;
+    authThinkingLevel?: TurnThinkingSelection["thinkingLevel"];
+    authUsage?: AgentTurnUsage;
+    checkpointVersion?: number;
+    conversationId?: string;
+    sessionId?: string;
+    sliceId?: number;
+}
+/** Error indicating the turn can be retried (timeout or auth pause). */
+export declare class RetryableTurnError extends Error {
+    readonly code = "retryable_turn";
+    readonly metadata?: RetryableTurnMetadata;
+    readonly reason: RetryableTurnReason;
+    constructor(reason: RetryableTurnReason, message: string, metadata?: RetryableTurnMetadata);
+}
+export declare function isRetryableTurnError(error: unknown, reason?: RetryableTurnReason): error is RetryableTurnError;
+/** Mark a turn as the active turn in conversation state. */
+export declare function startActiveTurn(args: {
+    conversation: ThreadConversationState;
+    nextTurnId: string;
+    updateConversationStats: (conversation: ThreadConversationState) => void;
+}): void;
+/**
+ * Close the active turn without marking a Pi session reusable for future
+ * history. Use this for auth handoffs and recovery replies that end the live
+ * turn but do not produce a completed Pi session.
+ */
+export declare function markTurnClosed(args: {
+    conversation: ThreadConversationState;
+    nowMs: number;
+    sessionId?: string;
+    updateConversationStats: (conversation: ThreadConversationState) => void;
+}): void;
+/**
+ * Mark a turn as completed after final reply delivery succeeds and make its Pi
+ * session the reusable history source for the next turn.
+ */
+export declare function markTurnCompleted(args: {
+    conversation: ThreadConversationState;
+    nowMs: number;
+    sessionId: string;
+    updateConversationStats: (conversation: ThreadConversationState) => void;
+}): void;
+/**
+ * Mark a turn as failed when execution or final user-visible reply delivery
+ * cannot be completed. If `sessionId` is provided, `activeTurnId` is only
+ * cleared when it still matches the failing turn.
+ */
+export declare function markTurnFailed(args: {
+    conversation: ThreadConversationState;
+    nowMs: number;
+    sessionId?: string;
+    userMessageId?: string;
+    markConversationMessage: (conversation: ThreadConversationState, messageId: string | undefined, patch: {
+        replied?: boolean;
+        skippedReason?: string;
+    }) => void;
+    updateConversationStats: (conversation: ThreadConversationState) => void;
+}): void;

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

@@ -0,0 +1,11 @@
+interface VercelSandboxCredentials {
+    teamId: string;
+    projectId: string;
+    token: string;
+}
+/**
+ * Resolve explicit Vercel Sandbox credentials, or return undefined to let
+ * the SDK read ambient Vercel auth from its own environment detection.
+ */
+export declare function getVercelSandboxCredentials(): VercelSandboxCredentials | undefined;
+export {};

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

@@ -0,0 +1,3 @@
+import { type JWTPayload } from "jose";
+/** Verify Vercel signed this Sandbox firewall proxy request for the active VM session. */
+export declare function verifyVercelSandboxOidcToken(token: string): Promise<JWTPayload>;

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

@@ -0,0 +1,11 @@
+import type { NetworkPolicy } from "@vercel/sandbox";
+/** Return whether an outbound host is covered by a sandbox egress domain rule. */
+export declare function matchesSandboxEgressDomain(host: string, domain: string): boolean;
+/** Resolve the plugin provider responsible for an outbound sandbox host. */
+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;
+}): NetworkPolicy;
+/** Resolve non-secret command environment values for registered sandbox providers. */
+export declare function resolveSandboxCommandEnvironment(): Promise<Record<string, string>>;

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

@@ -0,0 +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 headers. */
+export declare function proxySandboxEgressRequest(request: Request, deps?: ProxyDeps): Promise<Response>;
+export {};

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

@@ -0,0 +1,27 @@
+import type { CredentialHeaderTransform } from "@/chat/credentials/broker";
+export declare const SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
+export interface SandboxEgressRequesterContext {
+    requesterId: string;
+    egressId: string;
+    expiresAtMs: number;
+    contextId: string;
+}
+export interface SandboxEgressCredentialLease {
+    provider: string;
+    expiresAt: string;
+    headerTransforms: CredentialHeaderTransform[];
+}
+/** Create a signed requester/sandbox context token for lazy sandbox egress auth. */
+export declare function createSandboxEgressRequesterToken(input: {
+    requesterId: string;
+    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>;
+/** Clear a cached egress credential lease after the provider rejects its headers. */
+export declare function clearSandboxEgressCredentialLease(provider: string, context: SandboxEgressRequesterContext): Promise<void>;

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

@@ -0,0 +1,12 @@
+/** Detect sandbox filesystem operations that can safely ignore existing directories. */
+export declare function isAlreadyExistsError(error: unknown): boolean;
+/** Detect when a cached sandbox can no longer be reused and must be recreated. */
+export declare function isSandboxUnavailableError(error: unknown): boolean;
+/** Detect transient snapshot boot races so sandbox creation can retry. */
+export declare function isSnapshottingError(error: unknown): boolean;
+/** Detect interrupted command streams where no reliable exit status is available. */
+export declare function isSandboxCommandStreamInterruptedError(error: unknown): boolean;
+/** Wrap raw sandbox setup failures into one stable user-facing error contract. */
+export declare function wrapSandboxSetupError(error: unknown): Error;
+/** Record span data and throw one stable sandbox operation error. */
+export declare function throwSandboxOperationError(action: string, error: unknown, includeMissingPath?: boolean): never;

package/dist/chat/sandbox/http-error-details.d.ts

@@ -0,0 +1,18 @@
+interface ExtraFieldOption {
+    sourceKey: string;
+    attributeKey: string;
+    summaryKey?: string;
+}
+export interface ExtractHttpErrorDetailsOptions {
+    attributePrefix?: string;
+    previewLimit?: number;
+    extraFields?: ExtraFieldOption[];
+}
+export interface ExtractedHttpErrorDetails {
+    attributes: Record<string, string | number | boolean | string[]>;
+    summary: string;
+    searchableText: string;
+}
+/** Extract structured HTTP error metadata (status, headers, body preview) for logging. */
+export declare function extractHttpErrorDetails(error: unknown, options?: ExtractHttpErrorDetailsOptions): ExtractedHttpErrorDetails;
+export {};

package/dist/chat/sandbox/noninteractive-command.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxCommandResult, SandboxWorkspace } from "@/chat/sandbox/workspace";
+interface NonInteractiveShellOptions {
+    env?: Record<string, string>;
+    pathPrefix?: string;
+}
+interface NonInteractiveCommandInput extends NonInteractiveShellOptions {
+    args?: string[];
+    cmd: string;
+    cwd?: string;
+    login?: boolean;
+    sudo?: boolean;
+}
+/** Build one shell entrypoint that never waits on terminal input. */
+export declare function buildNonInteractiveShellScript(script: string, options?: NonInteractiveShellOptions): string;
+/** Run a subprocess through one enforced non-interactive entrypoint. */
+export declare function runNonInteractiveCommand(sandbox: Pick<SandboxWorkspace, "runCommand">, input: NonInteractiveCommandInput): Promise<SandboxCommandResult>;
+export {};

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

@@ -0,0 +1,5 @@
+export declare const SANDBOX_WORKSPACE_ROOT: string;
+export declare const SANDBOX_SKILLS_ROOT: string;
+export declare const SANDBOX_DATA_ROOT: string;
+export declare function sandboxSkillDir(skillName: string): string;
+export declare function sandboxSkillFile(skillName: string): string;

package/dist/chat/sandbox/runtime-dependency-snapshots.d.ts

@@ -0,0 +1,20 @@
+export type SnapshotResolveOutcome = "no_profile" | "cache_hit" | "cache_hit_after_lock_wait" | "rebuilt" | "forced_rebuild";
+export type SnapshotRebuildReason = "cache_miss" | "floating_stale" | "force_rebuild" | "snapshot_missing";
+export interface RuntimeDependencySnapshot {
+    snapshotId?: string;
+    profileHash?: string;
+    dependencyCount: number;
+    cacheHit: boolean;
+    resolveOutcome: SnapshotResolveOutcome;
+    rebuildReason?: SnapshotRebuildReason;
+}
+export type RuntimeDependencySnapshotProgressPhase = "resolve_start" | "cache_hit" | "waiting_for_lock" | "building_snapshot" | "build_complete";
+export declare function getRuntimeDependencyProfileHash(runtime: string): string | undefined;
+export declare function resolveRuntimeDependencySnapshot(params: {
+    runtime: string;
+    timeoutMs: number;
+    forceRebuild?: boolean;
+    staleSnapshotId?: string;
+    onProgress?: (phase: RuntimeDependencySnapshotProgressPhase) => void | Promise<void>;
+}): Promise<RuntimeDependencySnapshot>;
+export declare function isSnapshotMissingError(error: unknown): boolean;

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

@@ -0,0 +1,54 @@
+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 {
+    toolName: string;
+    input: unknown;
+}
+export interface SandboxExecutionEnvelope<T = unknown> {
+    result: T;
+}
+export interface BashCustomCommandResult {
+    ok: boolean;
+    command: string;
+    cwd: string;
+    exit_code: number;
+    signal: null;
+    timed_out: boolean;
+    stdout: string;
+    stderr: string;
+    stdout_truncated: boolean;
+    stderr_truncated: boolean;
+}
+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;
+    timeoutMs?: number;
+    traceContext?: LogContext;
+    credentialEgress?: {
+        requesterId: string;
+    };
+    agentHooks?: AgentPluginHookRunner;
+    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
+    runBashCustomCommand?: (command: string) => Promise<{
+        handled: boolean;
+        result?: BashCustomCommandResult;
+    }>;
+}): SandboxExecutor;
+export {};

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

@@ -0,0 +1,54 @@
+import { type NetworkPolicy } from "@vercel/sandbox";
+import { type LogContext } from "@/chat/logging";
+import { type SandboxFileSystem, type SandboxInstance } from "@/chat/sandbox/workspace";
+import type { SkillMetadata } from "@/chat/skills";
+interface SandboxToolExecutors {
+    bash: (input: {
+        command: string;
+        env?: Record<string, string>;
+        timeoutMs?: number;
+    }) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        stdoutTruncated: boolean;
+        stderrTruncated: boolean;
+        timedOut?: boolean;
+    }>;
+    readFile: (input: {
+        path: string;
+    }) => Promise<{
+        content: string;
+    }>;
+    writeFile: (input: {
+        path: string;
+        content: string;
+    }) => Promise<{
+        success: boolean;
+    }>;
+    fs: SandboxFileSystem;
+}
+interface SandboxSessionManager {
+    configureSkills(skills: SkillMetadata[]): void;
+    configureReferenceFiles(files: string[]): void;
+    getSandboxId(): string | undefined;
+    getDependencyProfileHash(): string | undefined;
+    createSandbox(): Promise<SandboxInstance>;
+    ensureToolExecutors(): Promise<SandboxToolExecutors>;
+    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;
+    timeoutMs?: number;
+    traceContext?: LogContext;
+    commandEnv?: () => Promise<Record<string, string>>;
+    createNetworkPolicy?: (egressId: string) => NetworkPolicy | undefined;
+    onSandboxPrepare?: (sandbox: SandboxInstance) => void | Promise<void>;
+    onSandboxAcquired?: (sandbox: {
+        sandboxId: string;
+        sandboxDependencyProfileHash?: string;
+    }) => void | Promise<void>;
+}): SandboxSessionManager;
+export {};

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

@@ -0,0 +1,42 @@
+import { type Skill, type SkillMetadata } from "@/chat/skills";
+export interface SkillSandboxFileEntry {
+    path: string;
+    type: "file" | "directory";
+}
+export interface SkillSandboxListFilesResult {
+    skillName: string;
+    directory: string;
+    entries: SkillSandboxFileEntry[];
+    truncated: boolean;
+}
+export interface SkillSandboxReadFileResult {
+    skillName: string;
+    path: string;
+    content: string;
+    truncated: boolean;
+}
+/** Sandboxed file access scoped to the active skill's directory — prevents path traversal. */
+export declare class SkillSandbox {
+    private readonly availableSkills;
+    private readonly availableByName;
+    private readonly loadedSkills;
+    private activeSkillName;
+    constructor(availableSkills: SkillMetadata[], preloadedSkills?: Skill[]);
+    getAvailableSkills(): SkillMetadata[];
+    getLoadedSkillNames(): string[];
+    getActiveSkill(): Skill | null;
+    loadSkill(skillName: string): Promise<Skill | null>;
+    filterToolNames(toolNames: string[]): string[] | null;
+    listFiles(params: {
+        skillName?: string;
+        directory?: string;
+        recursive?: boolean;
+        maxEntries?: number;
+    }): Promise<SkillSandboxListFilesResult>;
+    readFile(params: {
+        skillName?: string;
+        filePath: string;
+        maxChars?: number;
+    }): Promise<SkillSandboxReadFileResult>;
+    private requireSkill;
+}

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

@@ -0,0 +1,16 @@
+import type { SandboxInstance } 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;
+/** Resolve a virtual sandbox data path back to the host filesystem when no sandbox exists yet. */
+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. */
+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>;
+    workspaceRoot?: string;
+}): Promise<void>;

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

@@ -0,0 +1,55 @@
+import type { NetworkPolicy, Sandbox as VercelSandbox } from "@vercel/sandbox";
+export interface SandboxCommandResult {
+    exitCode: number;
+    stderr(): Promise<string>;
+    stdout(): Promise<string>;
+}
+export interface SandboxCommandInput {
+    args?: string[];
+    cmd: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+    sudo?: boolean;
+}
+export interface SandboxFileStat {
+    isDirectory(): boolean;
+}
+export interface SandboxFileSystem {
+    readFile(filePath: string, options: {
+        encoding: BufferEncoding;
+    }): Promise<string>;
+    writeFile(filePath: string, content: string, options?: {
+        encoding?: BufferEncoding;
+    }): Promise<void>;
+    readdir(filePath: string): Promise<string[]>;
+    stat(filePath: string): Promise<SandboxFileStat>;
+}
+export interface SandboxWorkspace {
+    readFileToBuffer(input: {
+        cwd?: string;
+        path: string;
+    }): Promise<Buffer | null | undefined>;
+    runCommand(input: SandboxCommandInput): Promise<SandboxCommandResult>;
+}
+export interface SandboxInstance extends SandboxWorkspace {
+    readonly sandboxId: string;
+    readonly sandboxEgressId: string;
+    readonly fs: SandboxFileSystem;
+    extendTimeout(duration: number): Promise<void>;
+    mkDir(path: string): Promise<void>;
+    snapshot(): Promise<{
+        snapshotId: string;
+    }>;
+    stop(): Promise<unknown>;
+    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;

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;