@sentry/junior 0.53.0 → 0.54.0

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

@@ -0,0 +1,77 @@
+/**
+ * Pure helper functions used by the agent reply orchestration in respond.ts.
+ *
+ * These are extracted to reduce the size of the main orchestration module and
+ * make individual helpers independently testable.
+ */
+import type { AssistantMessage, ToolResultMessage } from "@earendil-works/pi-ai";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { Skill } from "@/chat/skills";
+/** Extract conversation and session identifiers from correlation context. */
+export declare function getSessionIdentifiers(context: {
+    correlation?: {
+        conversationId?: string;
+        threadId?: string;
+        turnId?: string;
+        runId?: string;
+    };
+}): {
+    conversationId?: string;
+    sessionId?: string;
+};
+/** Detect polite execution deferral phrases that signal the model is stalling. */
+export declare function isExecutionDeferralResponse(text: string): boolean;
+/** Detect disclaimers about missing tool access. */
+export declare function isToolAccessDisclaimerResponse(text: string): boolean;
+/** True when the model produced an escape response instead of executing. */
+export declare function isExecutionEscapeResponse(text: string): boolean;
+/** Best-effort JSON extraction from text that may contain fenced blocks. */
+export declare function parseJsonCandidate(text: string): unknown;
+/** Check whether a parsed object looks like a raw tool call/result payload. */
+export declare function isToolPayloadShape(payload: unknown): boolean;
+/** Detect responses that are raw tool payloads leaked as text. */
+export declare function isRawToolPayloadResponse(text: string): boolean;
+/** Redact image data from prompt content parts for observability. */
+export declare function toObservablePromptPart(part: {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+}): Record<string, unknown>;
+/** Truncate message text for log attributes. */
+export declare function summarizeMessageText(text: string): string;
+/**
+ * Put prior thread text before the current instruction when no Pi history
+ * exists. These are top-level sibling blocks in the user message.
+ */
+export declare function buildUserTurnText(userInput: string, conversationContext?: string): string;
+/** Encode a non-image attachment as base64 XML for the prompt. */
+export declare function encodeNonImageAttachmentForPrompt(attachment: {
+    data: Buffer;
+    mediaType: string;
+    filename?: string;
+}): string;
+/** Type guard for Pi SDK tool result messages. */
+export declare function isToolResultMessage(value: unknown): value is ToolResultMessage<any>;
+/** Extract the tool name from a raw tool result message. */
+export declare function normalizeToolNameFromResult(result: unknown): string | undefined;
+/** Check whether a tool result carries an error flag. */
+export declare function isToolResultError(result: unknown): boolean;
+/** Type guard for Pi SDK assistant messages. */
+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 a checkpoint before continuing Pi. */
+export declare function refreshRuntimeTurnContext(messages: PiMessage[], turnContextPrompt: string): PiMessage[];
+/** Remove volatile runtime context before using checkpoint messages as history. */
+export declare function stripRuntimeTurnContext(messages: PiMessage[]): PiMessage[];
+/** Concatenate text content parts from an assistant message. */
+export declare function extractAssistantText(message: AssistantMessage): string;
+/** Return assistant messages that belong to the terminal post-tool reply phase. */
+export declare function getTerminalAssistantMessages(messages: readonly unknown[]): AssistantMessage[];
+/** Upsert a skill into the active skills list by name. */
+export declare function upsertActiveSkill(activeSkills: Skill[], next: Skill): void;
+/** Remove trailing assistant messages before checkpointing. */
+export declare function trimTrailingAssistantMessages(messages: PiMessage[]): PiMessage[];

package/dist/chat/respond.d.ts

@@ -0,0 +1,64 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { ConversationPendingAuthState } from "@/chat/state/conversation";
+import type { ImageGenerateToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
+import type { PiMessage } from "@/chat/pi/messages";
+import { type SandboxAcquiredState } from "@/chat/sandbox/sandbox";
+import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
+import { type AssistantReply, type AgentTurnDiagnostics } from "@/chat/services/turn-result";
+export type { AssistantReply, AgentTurnDiagnostics };
+export interface ReplyRequestContext {
+    skillDirs?: string[];
+    requester?: {
+        userId?: string;
+        userName?: string;
+        fullName?: string;
+    };
+    correlation?: {
+        conversationId?: string;
+        threadId?: string;
+        turnId?: string;
+        runId?: string;
+        channelId?: string;
+        messageTs?: string;
+        threadTs?: string;
+        requesterId?: string;
+    };
+    toolChannelId?: string;
+    conversationContext?: string;
+    artifactState?: ThreadArtifactsState;
+    pendingAuth?: ConversationPendingAuthState;
+    configuration?: Record<string, unknown>;
+    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
+    piMessages?: PiMessage[];
+    channelConfiguration?: ChannelConfigurationService;
+    userAttachments?: Array<{
+        data?: Buffer;
+        mediaType: string;
+        filename?: string;
+        promptText?: string;
+    }>;
+    inboundAttachmentCount?: number;
+    omittedImageAttachmentCount?: number;
+    sandbox?: {
+        sandboxId?: string;
+        sandboxDependencyProfileHash?: string;
+    };
+    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
+    onArtifactStateUpdated?: (artifactState: ThreadArtifactsState) => void | Promise<void>;
+    toolOverrides?: {
+        imageGenerate?: ImageGenerateToolDeps;
+        webFetch?: WebFetchToolDeps;
+        webSearch?: WebSearchToolDeps;
+    };
+    onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
+    onAuthPending?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    onTextDelta?: (deltaText: string) => void | Promise<void>;
+    onAssistantMessageStart?: () => void | Promise<void>;
+    onToolInvocation?: (invocation: {
+        toolName: string;
+        params: Record<string, unknown>;
+    }) => void;
+}
+/** 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/auth-pause-state.d.ts

@@ -0,0 +1,11 @@
+import { type ThreadConversationState } from "@/chat/state/conversation";
+/** Mark an auth-paused turn complete after private authorization link delivery. */
+export declare function completeAuthPauseTurn(args: {
+    conversation: ThreadConversationState;
+    sessionId: string;
+}): void;
+/** Reload thread state, mark the auth pause as parked, and persist it. */
+export declare function persistAuthPauseTurnState(args: {
+    sessionId: string;
+    threadStateId: string;
+}): Promise<void>;

package/dist/chat/runtime/delivered-turn-state.d.ts

@@ -0,0 +1,15 @@
+import type { AssistantReply } from "@/chat/respond";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import { type ThreadStatePatch } from "@/chat/runtime/thread-state";
+/** Build the canonical thread-state patch after final Slack delivery succeeds. */
+export declare function buildDeliveredTurnStatePatch(args: {
+    artifactStatePatch?: Partial<ThreadArtifactsState>;
+    artifacts: ThreadArtifactsState;
+    conversation: ThreadConversationState;
+    reply: AssistantReply;
+    sessionId: string;
+    userMessageId?: string;
+}): ThreadStatePatch & {
+    conversation: ThreadConversationState;
+};

package/dist/chat/runtime/dev-agent-trace.d.ts

@@ -0,0 +1 @@
+export declare function shouldEmitDevAgentTrace(): boolean;

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

@@ -0,0 +1,25 @@
+import type { Message, Thread } from "chat";
+/** Controls the automatic Slack processing reaction lifecycle for one message. */
+export interface ProcessingReactionSession {
+    keep: () => void;
+    stop: () => Promise<void>;
+}
+/** Return true when a Slack reaction tool call should leave the processing reaction in place. */
+export declare function shouldKeepProcessingReactionForToolInvocation(input: {
+    params: Record<string, unknown>;
+    toolName: string;
+}): boolean;
+/** Start Junior's automatic Slack processing reaction for one inbound message. */
+export declare function startSlackProcessingReaction(args: {
+    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+    logContext: Record<string, unknown>;
+    message: Message;
+    thread: Thread;
+}): Promise<ProcessingReactionSession>;
+/** Start Junior's automatic Slack processing reaction for a known Slack message. */
+export declare function startSlackProcessingReactionForMessage(args: {
+    channelId: string;
+    timestamp: string;
+    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+    logContext: Record<string, unknown>;
+}): Promise<ProcessingReactionSession>;

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

@@ -0,0 +1,56 @@
+import type { Message, Thread } from "chat";
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
+import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
+import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import { lookupSlackUser } from "@/chat/slack/user";
+import type { TurnContinuationRequest } from "@/chat/services/timeout-resume";
+export interface ReplyExecutorServices {
+    generateAssistantReply: typeof generateAssistantReplyImpl;
+    generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
+    getAwaitingTurnContinuationRequest: (args: {
+        conversationId: string;
+        sessionId: string;
+    }) => Promise<TurnContinuationRequest | undefined>;
+    lookupSlackUser: typeof lookupSlackUser;
+    scheduleTurnTimeoutResume: (request: TurnContinuationRequest) => Promise<void>;
+}
+interface ReplyExecutorDeps {
+    getSlackAdapter: () => SlackAdapter;
+    resolveUserAttachments: (attachments: Message["attachments"] | undefined, context: {
+        threadId?: string;
+        requesterId?: string;
+        channelId?: string;
+        runId?: string;
+        conversation?: PreparedTurnState["conversation"];
+        messageTs?: string;
+    }) => Promise<Array<{
+        data?: Buffer;
+        mediaType: string;
+        filename?: string;
+        promptText?: string;
+    }>>;
+    prepareTurnState: (args: {
+        explicitMention: boolean;
+        message: Message;
+        thread: Thread;
+        userText: string;
+        context: {
+            threadId?: string;
+            requesterId?: string;
+            channelId?: string;
+            runId?: string;
+        };
+    }) => Promise<PreparedTurnState>;
+    services: ReplyExecutorServices;
+}
+export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options?: {
+    beforeFirstResponsePost?: () => Promise<void>;
+    explicitMention?: boolean;
+    onToolInvocation?: (invocation: {
+        params: Record<string, unknown>;
+        toolName: string;
+    }) => void;
+    preparedState?: PreparedTurnState;
+}) => Promise<void>;
+export {};

package/dist/chat/runtime/report-progress.d.ts

@@ -0,0 +1,3 @@
+import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status-render";
+/** Convert a `reportProgress` tool payload into assistant status text. */
+export declare function buildReportedProgressStatus(input: unknown): AssistantStatusSpec | undefined;

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

@@ -0,0 +1,50 @@
+import { generateAssistantReply, type AssistantReply, type ReplyRequestContext } from "@/chat/respond";
+/** Error raised when another worker already owns the resume lock. */
+export declare class ResumeTurnBusyError extends Error {
+    constructor(lockKey: string);
+}
+interface ResumeSlackTurnArgs {
+    messageText: string;
+    channelId: string;
+    threadTs: string;
+    messageTs?: string;
+    replyContext?: ReplyRequestContext;
+    lockKey?: string;
+    initialText?: string;
+    generateReply?: typeof generateAssistantReply;
+    onSuccess?: (reply: AssistantReply) => Promise<void>;
+    onFailure?: (error: unknown) => Promise<void>;
+    onAuthPause?: (error: unknown) => Promise<void>;
+    onTimeoutPause?: (error: unknown) => Promise<void>;
+    onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
+    beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
+    replyTimeoutMs?: number;
+}
+/**
+ * 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.
+ */
+export declare function resumeSlackTurn(args: ResumeSlackTurnArgs): Promise<void>;
+/** Resume an OAuth-paused Slack request through the shared resume runner. */
+export declare function resumeAuthorizedRequest(args: {
+    messageText: string;
+    channelId: string;
+    threadTs: string;
+    messageTs?: string;
+    connectedText: string;
+    replyContext?: ReplyRequestContext;
+    lockKey?: string;
+    generateReply?: typeof generateAssistantReply;
+    onSuccess?: (reply: AssistantReply) => Promise<void>;
+    onFailure?: (error: unknown) => Promise<void>;
+    onAuthPause?: (error: unknown) => Promise<void>;
+    onTimeoutPause?: (error: unknown) => Promise<void>;
+    onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
+    beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
+    replyTimeoutMs?: number;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,100 @@
+import type { Message, Thread } from "chat";
+import type { SubscribedReplyDecision } from "@/chat/services/subscribed-reply-policy";
+export interface AssistantLifecycleEvent {
+    channelId: string;
+    context?: {
+        channelId?: string;
+    };
+    threadId: string;
+    threadTs: string;
+    userId?: string;
+}
+export interface ThreadContext {
+    channelId?: string;
+    requesterId?: string;
+    threadId?: string;
+    runId?: string;
+}
+export interface ReplyHooks {
+    beforeFirstResponsePost?: () => Promise<void>;
+    onToolInvocation?: (invocation: {
+        params: Record<string, unknown>;
+        toolName: string;
+    }) => void;
+}
+export interface SlackTurnRuntimeDependencies<TPreparedState> {
+    assistantUserName: string;
+    getChannelId: (thread: Thread, message: Message) => string | undefined;
+    getPreparedConversationContext: (preparedState: TPreparedState) => string | undefined;
+    getThreadId: (thread: Thread, message: Message) => string | undefined;
+    getRunId: (thread: Thread, message: Message) => string | undefined;
+    initializeAssistantThread: (event: {
+        channelId: string;
+        sourceChannelId?: string;
+        threadId: string;
+        threadTs: string;
+    }) => Promise<void>;
+    refreshAssistantThreadContext: (event: {
+        channelId: string;
+        sourceChannelId?: string;
+        threadId: string;
+        threadTs: string;
+    }) => Promise<void>;
+    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+    logWarn: (eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => void;
+    modelId: string;
+    now: () => number;
+    recordSkippedSubscribedMessage: (args: {
+        completedAtMs: number;
+        decision: SubscribedReplyDecision;
+        message: Message;
+        thread: Thread;
+        userText: string;
+    }) => Promise<void>;
+    onSubscribedMessageSkipped: (args: {
+        completedAtMs: number;
+        decision: SubscribedReplyDecision;
+        message: Message;
+        preparedState?: TPreparedState;
+        thread: Thread;
+    }) => Promise<void>;
+    persistPreparedState: (args: {
+        preparedState: TPreparedState;
+        thread: Thread;
+    }) => Promise<void>;
+    prepareTurnState: (args: {
+        context: ThreadContext;
+        explicitMention: boolean;
+        message: Message;
+        thread: Thread;
+        userText: string;
+    }) => Promise<TPreparedState>;
+    replyToThread: (thread: Thread, message: Message, options?: {
+        beforeFirstResponsePost?: () => Promise<void>;
+        explicitMention?: boolean;
+        onToolInvocation?: (invocation: {
+            params: Record<string, unknown>;
+            toolName: string;
+        }) => void;
+        preparedState?: TPreparedState;
+    }) => Promise<void>;
+    decideSubscribedReply: (args: {
+        context: ThreadContext;
+        conversationContext?: string;
+        hasAttachments?: boolean;
+        isExplicitMention?: boolean;
+        rawText: string;
+        text: string;
+    }) => Promise<SubscribedReplyDecision>;
+    stripLeadingBotMention: (text: string, options: {
+        stripLeadingSlackMentionToken?: boolean;
+    }) => string;
+    withSpan: (name: string, op: string, context: Record<string, unknown>, callback: () => Promise<void>) => Promise<void>;
+}
+export interface SlackTurnRuntime<_TPreparedState, TAssistantEvent extends AssistantLifecycleEvent = AssistantLifecycleEvent> {
+    handleAssistantContextChanged: (event: TAssistantEvent) => Promise<void>;
+    handleAssistantThreadStarted: (event: TAssistantEvent) => Promise<void>;
+    handleNewMention: (thread: Thread, message: Message, hooks?: ReplyHooks) => Promise<void>;
+    handleSubscribedMessage: (thread: Thread, message: Message, hooks?: ReplyHooks) => Promise<void>;
+}
+export declare function createSlackTurnRuntime<TPreparedState, TAssistantEvent extends AssistantLifecycleEvent = AssistantLifecycleEvent>(deps: SlackTurnRuntimeDependencies<TPreparedState>): SlackTurnRuntime<TPreparedState, TAssistantEvent>;

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

@@ -0,0 +1,22 @@
+import type { Message, Thread } from "chat";
+export declare function stripLeadingBotMention(text: string, options?: {
+    stripLeadingSlackMentionToken?: boolean;
+}): 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;
+export declare function getThreadTs(threadId: string | undefined): string | undefined;
+/**
+ * Resolve Slack assistant-thread API context for the current turn.
+ *
+ * Slack assistant-thread methods must use the live inbound thread context
+ * Slack provided on the current message. Slack's assistant utilities build
+ * `setStatus`/`setTitle` from `message.channel` plus `message.thread_ts ?? message.ts`
+ * for non-DM message events, while `message.im` still requires an explicit
+ * `thread_ts`. Do not synthesize assistant-thread roots from persisted state.
+ */
+export declare function getAssistantThreadContext(message: Message): {
+    channelId: string;
+    threadTs: string;
+} | undefined;
+export declare function getMessageTs(message: Message): string | undefined;

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,10 @@
+import type { JWTPayload } from "jose";
+interface ProxyDeps {
+    fetch?: typeof fetch;
+    verifyOidc?: (token: string) => Promise<JWTPayload>;
+}
+/** Return whether a request appears to be from the Vercel Sandbox egress proxy. */
+export declare function isSandboxEgressForwardedRequest(request: Request): boolean;
+/** Proxy one Vercel Sandbox firewall egress request through lazy credential injection. */
+export declare function proxySandboxEgressRequest(request: Request, deps?: ProxyDeps): Promise<Response>;
+export {};