@sentry/junior 0.65.0 → 0.65.1

package/dist/chat/services/turn-session-record.d.ts

@@ -1,6 +1,7 @@
 import { type AgentTurnSessionRecord, type AgentTurnRequester } from "@/chat/state/turn-session";
 import type { PiMessage } from "@/chat/pi/messages";
 import { type AgentTurnUsage } from "@/chat/usage";
+export declare const AGENT_TURN_TIMEOUT_RESUME_MAX_SLICES = 48;
 export interface TurnSessionContext {
     conversationId?: string;
     sessionId?: string;
@@ -31,7 +32,7 @@ export declare function persistRunningSessionRecord(args: {
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
     requester?: AgentTurnRequester;
-}): Promise<void>;
+}): Promise<boolean>;
 /** Persist a completed turn session record. */
 export declare function persistCompletedSessionRecord(args: {
     channelName?: string;
@@ -64,7 +65,7 @@ export declare function persistAuthPauseSessionRecord(args: {
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
  * Persist a timeout session record at the last safe boundary. Returns the durable
- * record when persistence succeeds so callers can enqueue a continuation.
+ * record so callers can distinguish scheduled continuations from terminal caps.
  */
 export declare function persistTimeoutSessionRecord(args: {
     channelName?: string;
@@ -79,4 +80,20 @@ export declare function persistTimeoutSessionRecord(args: {
     logContext: SessionRecordLogContext;
     requester?: AgentTurnRequester;
 }): Promise<AgentTurnSessionRecord | undefined>;
+/**
+ * Persist a cooperative-yield boundary without advancing timeout slice counts.
+ */
+export declare function persistYieldSessionRecord(args: {
+    channelName?: string;
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames?: string[];
+    errorMessage: string;
+    logContext: SessionRecordLogContext;
+    requester?: AgentTurnRequester;
+}): Promise<AgentTurnSessionRecord | undefined>;
 export {};

package/dist/chat/slack/adapter-context.d.ts

@@ -0,0 +1,25 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import type { StateAdapter } from "chat";
+export interface SlackInstallationContext {
+    enterpriseId?: string;
+    isEnterpriseInstall?: boolean;
+    teamId?: string;
+}
+/** Initialize the Slack adapter against the repository state adapter. */
+export declare function ensureSlackAdapterInitialized(args: {
+    adapter: SlackAdapter;
+    state?: StateAdapter;
+}): Promise<void>;
+/** Verify a Slack request using the adapter's configured signing secret. */
+export declare function verifySlackSignature(args: {
+    adapter: SlackAdapter;
+    body: string;
+    request: Request;
+}): boolean;
+/** Run Slack work with the installation token that matches the inbound event. */
+export declare function runWithSlackInstallation<T>(args: {
+    adapter: SlackAdapter;
+    installation: SlackInstallationContext;
+    state?: StateAdapter;
+    task: () => T | Promise<T>;
+}): Promise<T>;

package/dist/chat/slack/conversation-context.d.ts

@@ -0,0 +1,28 @@
+/** Slack Events API channel_type values relevant to message surfaces. */
+export type SlackEventChannelType = "channel" | "group" | "mpim" | "im";
+/** Slack conversation categories Junior can share with agents. */
+export type SlackConversationType = "public_channel" | "private_channel" | "group_dm" | "direct_message" | "private_channel_or_group_dm";
+/** Slack conversation facts available to the bot for runtime context. */
+export interface SlackConversationContext {
+    type: SlackConversationType;
+    name?: string;
+}
+/** Resolve Slack's raw event channel type from a Chat SDK message-like object. */
+export declare function resolveSlackChannelTypeFromMessage(message: unknown): SlackEventChannelType | undefined;
+/** Build Slack conversation facts available to runtime consumers. */
+export declare function resolveSlackConversationContext(input: {
+    channelId?: string;
+    channelName?: string;
+    channelType?: SlackEventChannelType;
+}): SlackConversationContext | undefined;
+/** Build Slack conversation facts from Junior's persisted Slack thread id. */
+export declare function resolveSlackConversationContextFromThreadId(input: {
+    threadId?: string;
+    channelName?: string;
+}): SlackConversationContext | undefined;
+/** Render a human label for a privacy-preserving Slack conversation type. */
+export declare function formatSlackConversationTypeLabel(type: SlackConversationType): string;
+/** Render a Slack conversation label for surfaces allowed to expose names. */
+export declare function formatSlackConversationContextLabel(context: SlackConversationContext | undefined): string | undefined;
+/** Render a Slack conversation label without exposing conversation names. */
+export declare function formatSlackConversationRedactedLabel(context: SlackConversationContext | undefined): string | undefined;

package/dist/chat/state/turn-session.d.ts

@@ -1,7 +1,7 @@
 import type { PiMessage } from "@/chat/pi/messages";
 import type { AgentTurnUsage } from "@/chat/usage";
 export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "abandoned";
-export type AgentTurnResumeReason = "timeout" | "auth";
+export type AgentTurnResumeReason = "timeout" | "auth" | "yield";
 export interface AgentTurnRequester {
     email?: string;
     fullName?: string;

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

@@ -0,0 +1,13 @@
+import type { StateAdapter } from "chat";
+import type { ConversationWorkQueue } from "./queue";
+export interface ConversationWorkRecoveryResult {
+    expiredLeaseCount: number;
+    pendingCount: number;
+}
+/** Requeue expired leases and stranded mailbox work without running the agent. */
+export declare function recoverConversationWork(args: {
+    limit?: number;
+    nowMs: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}): Promise<ConversationWorkRecoveryResult>;

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

@@ -0,0 +1,12 @@
+import type { ConversationQueueMessage } from "./queue";
+declare const CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION = "v1";
+interface SignedConversationQueueMessage extends ConversationQueueMessage {
+    signature: string;
+    signatureVersion: typeof CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION;
+    signedAtMs: number;
+}
+/** Sign a conversation queue payload before it crosses the public callback route. */
+export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): SignedConversationQueueMessage;
+/** Verify a signed conversation queue payload from the Vercel Queue callback. */
+export declare function verifySignedConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessage | undefined;
+export {};

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

@@ -0,0 +1,13 @@
+export interface ConversationQueueMessage {
+    conversationId: string;
+}
+export interface ConversationQueueSendOptions {
+    delayMs?: number;
+    idempotencyKey?: string;
+}
+export interface ConversationQueueSendResult {
+    messageId?: string;
+}
+export interface ConversationWorkQueue {
+    send(message: ConversationQueueMessage, options?: ConversationQueueSendOptions): Promise<ConversationQueueSendResult | void>;
+}

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

@@ -0,0 +1,32 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { Message, ThreadImpl, type SerializedMessage, type SerializedThread, type StateAdapter } from "chat";
+import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { InboundMessageRecord } from "@/chat/task-execution/store";
+import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
+import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
+export type SlackConversationRoute = "mention" | "subscribed";
+export interface SlackConversationMessageMetadata {
+    [key: string]: unknown;
+    installation?: SlackInstallationContext;
+    message: SerializedMessage;
+    platform: "slack";
+    route: SlackConversationRoute;
+    thread: SerializedThread;
+}
+export interface CreateSlackConversationWorkerOptions {
+    getSlackAdapter: () => SlackAdapter;
+    resumeAwaitingContinuation?: (conversationId: string) => Promise<boolean>;
+    runtime: Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
+    state?: StateAdapter;
+}
+/** Build the worker run function for queued Slack conversation work. */
+export declare function createSlackConversationWorker(options: CreateSlackConversationWorkerOptions): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
+/** Serialize a Slack message into the generic durable conversation mailbox. */
+export declare function buildSlackInboundMessage(args: {
+    conversationId: string;
+    installation?: SlackInstallationContext;
+    message: Message;
+    receivedAtMs: number;
+    route: SlackConversationRoute;
+    thread: ThreadImpl;
+}): InboundMessageRecord;

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

@@ -0,0 +1,153 @@
+import type { StateAdapter } from "chat";
+import type { ConversationWorkQueue } from "./queue";
+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 type InboundMessageSource = "plugin" | "scheduler" | "slack";
+export interface AgentInputMessage {
+    attachments?: unknown[];
+    authorId?: string;
+    metadata?: Record<string, unknown>;
+    text: string;
+}
+export interface InboundMessageRecord {
+    conversationId: string;
+    createdAtMs: number;
+    inboundMessageId: string;
+    injectedAtMs?: number;
+    input: AgentInputMessage;
+    receivedAtMs: number;
+    source: InboundMessageSource;
+}
+export interface ConversationLease {
+    acquiredAtMs: number;
+    lastCheckInAtMs: number;
+    leaseExpiresAtMs: number;
+    leaseToken: string;
+}
+export interface ConversationWorkState {
+    conversationId: string;
+    lastEnqueuedAtMs?: number;
+    lease?: ConversationLease;
+    messages: InboundMessageRecord[];
+    needsRun: boolean;
+    schemaVersion: 1;
+    updatedAtMs: number;
+}
+export interface ConversationLeaseAcquired {
+    leaseExpiresAtMs: number;
+    leaseToken: string;
+    status: "acquired";
+}
+export interface ConversationLeaseActive {
+    leaseExpiresAtMs: number;
+    status: "active";
+}
+export interface ConversationLeaseNoWork {
+    status: "no_work";
+}
+export type ConversationLeaseStartResult = ConversationLeaseAcquired | ConversationLeaseActive | ConversationLeaseNoWork;
+export interface AppendInboundMessageResult {
+    status: "appended" | "duplicate";
+}
+export interface AppendAndEnqueueInboundMessageResult extends AppendInboundMessageResult {
+    queueMessageId?: string;
+}
+export interface RequestConversationWorkResult {
+    status: "created" | "updated";
+}
+/** Return a persisted conversation work record, if one exists. */
+export declare function getConversationWorkState(args: {
+    conversationId: string;
+    state?: StateAdapter;
+}): Promise<ConversationWorkState | undefined>;
+/** Count mailbox messages that have not yet reached the session log. */
+export declare function countPendingConversationMessages(state: ConversationWorkState): number;
+/** Return whether a conversation has pending or resumable execution work. */
+export declare function hasRunnableConversationWork(state: ConversationWorkState): boolean;
+/** Persist one inbound message idempotently in its conversation mailbox. */
+export declare function appendInboundMessage(args: {
+    message: InboundMessageRecord;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<AppendInboundMessageResult>;
+/** Persist inbound work and send the queue nudge that wakes a worker. */
+export declare function appendAndEnqueueInboundMessage(args: {
+    message: InboundMessageRecord;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}): Promise<AppendAndEnqueueInboundMessageResult>;
+/** Mark a conversation runnable when there is no new mailbox message. */
+export declare function requestConversationWork(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<RequestConversationWorkResult>;
+/** Record that a wake-up nudge was accepted for the conversation. */
+export declare function markConversationWorkEnqueued(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<void>;
+/** Try to acquire the durable execution lease for one conversation. */
+export declare function startConversationWork(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ConversationLeaseStartResult>;
+/** Extend the durable execution lease when the worker checks in. */
+export declare function checkInConversationWork(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Drain pending mailbox entries after the caller has durably injected them. */
+export declare function drainConversationMailbox(args: {
+    conversationId: string;
+    inject: (messages: InboundMessageRecord[]) => Promise<void>;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<InboundMessageRecord[]>;
+/** Mark selected leased mailbox entries after their session-log injection succeeds. */
+export declare function markConversationMessagesInjected(args: {
+    conversationId: string;
+    inboundMessageIds: string[];
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Mark the leased conversation as needing another queue-delivered slice. */
+export declare function requestConversationContinuation(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;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** Finish a leased conversation and report whether runnable work remains. */
+export declare function completeConversationWork(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<"completed" | "lost_lease" | "pending">;
+/** Clear an expired durable lease so a later worker can resume safely. */
+export declare function clearExpiredConversationLease(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
+/** List bounded conversation ids that may need heartbeat recovery. */
+export declare function listConversationWorkIds(args?: {
+    limit?: number;
+    state?: StateAdapter;
+}): Promise<string[]>;

package/dist/chat/task-execution/vercel-callback.d.ts

@@ -0,0 +1,21 @@
+import type { StateAdapter } from "chat";
+import type { ConversationWorkQueue } from "./queue";
+import { type ConversationWorkProcessResult, type ConversationWorkerResult, type ConversationWorkerContext } from "./worker";
+export declare const CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS = 30;
+export interface ProcessConversationQueueMessageOptions {
+    checkInIntervalMs?: number;
+    nowMs?: () => number;
+    queue?: ConversationWorkQueue;
+    run(context: ConversationWorkerContext): Promise<ConversationWorkerResult>;
+    softYieldAfterMs?: number;
+    state?: StateAdapter;
+}
+export interface VercelConversationWorkCallbackOptions extends ProcessConversationQueueMessageOptions {
+    visibilityTimeoutSeconds?: number;
+}
+/** Resolve queue visibility so redelivery waits past the host timeout boundary. */
+export declare function resolveConversationWorkVisibilityTimeoutSeconds(functionMaxDurationSeconds?: number): number;
+/** Process one Vercel Queue payload with the generic conversation worker. */
+export declare function processConversationQueueMessage(message: unknown, options: ProcessConversationQueueMessageOptions): Promise<ConversationWorkProcessResult>;
+/** Create the Vercel Queue push callback for conversation work nudges. */
+export declare function createVercelConversationWorkCallback(options: VercelConversationWorkCallbackOptions): (request: Request) => Promise<Response>;

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

@@ -0,0 +1,16 @@
+import type { SendOptions, SendResult } from "@vercel/queue";
+import type { ConversationWorkQueue } from "./queue";
+export declare const DEFAULT_CONVERSATION_WORK_QUEUE_TOPIC = "junior_conversation_work";
+interface QueueSender {
+    send<T = unknown>(topicName: string, payload: T, options?: SendOptions): Promise<SendResult>;
+}
+export interface VercelConversationWorkQueueOptions {
+    client?: QueueSender;
+    retentionSeconds?: number;
+    topic?: string;
+}
+/** Create the Vercel Queue implementation for conversation wake-up nudges. */
+export declare function createVercelConversationWorkQueue(options?: VercelConversationWorkQueueOptions): ConversationWorkQueue;
+/** Return the default production conversation work queue. */
+export declare function getVercelConversationWorkQueue(): ConversationWorkQueue;
+export {};

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

@@ -0,0 +1,28 @@
+import type { StateAdapter } from "chat";
+import type { ConversationWorkQueue } from "./queue";
+import { type InboundMessageRecord } from "./store";
+export declare const CONVERSATION_WORK_DEFER_DELAY_MS = 15000;
+export declare const CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 240000;
+export interface ConversationWorkerContext {
+    checkIn(): Promise<boolean>;
+    conversationId: string;
+    drainMailbox(inject: (messages: InboundMessageRecord[]) => Promise<void>): Promise<InboundMessageRecord[]>;
+    leaseToken: string;
+    shouldYield(): boolean;
+}
+export interface ConversationWorkerResult {
+    status: "completed" | "lost_lease" | "yielded";
+}
+export interface ConversationWorkProcessResult {
+    status: "active" | "completed" | "lost_lease" | "no_work" | "pending_requeued" | "yielded";
+}
+export interface ProcessConversationWorkOptions {
+    checkInIntervalMs?: number;
+    nowMs?: () => number;
+    queue: ConversationWorkQueue;
+    run(context: ConversationWorkerContext): Promise<ConversationWorkerResult>;
+    softYieldAfterMs?: number;
+    state?: StateAdapter;
+}
+/** Process one queue wake-up for a conversation. */
+export declare function processConversationWork(conversationId: string, options: ProcessConversationWorkOptions): Promise<ConversationWorkProcessResult>;