@sentry/junior 0.198.0 → 0.199.0

package/dist/chat/state/conversation.d.ts

@@ -1,80 +0,0 @@
-type ConversationRole = "assistant" | "system" | "user";
-export interface ConversationAuthor {
-    email?: string;
-    fullName?: string;
-    isBot?: boolean;
-    userId?: string;
-    userName?: string;
-}
-export interface ConversationMessageMeta {
-    attachmentCount?: number;
-    /** Known message provenance. Omit when unknown; never invent a default. */
-    source?: "slack" | "web";
-    eventType?: string;
-    explicitMention?: boolean;
-    imageAttachmentCount?: number;
-    imageFileIds?: string[];
-    imagesHydrated?: boolean;
-    replied?: boolean;
-    slackTs?: string;
-    skippedReason?: string;
-}
-export interface ConversationMessage {
-    author?: ConversationAuthor;
-    createdAtMs: number;
-    id: string;
-    meta?: ConversationMessageMeta;
-    role: ConversationRole;
-    text: string;
-}
-export interface ConversationCompaction {
-    coveredMessageCount: number;
-    createdAtMs: number;
-    id: string;
-    summary: string;
-}
-export interface ConversationProcessingState {
-    activeTurnId?: string;
-    lastCompletedAtMs?: number;
-    pendingAuth?: ConversationPendingAuthState;
-}
-interface ConversationPendingAuthBase {
-    linkSentAtMs: number;
-    provider: string;
-    actorId: string;
-    scope?: string;
-    sessionId: string;
-}
-export type ConversationPendingAuthState = (ConversationPendingAuthBase & {
-    authSessionId: string;
-    kind: "mcp";
-}) | (ConversationPendingAuthBase & {
-    kind: "plugin";
-});
-export interface ConversationVisionSummary {
-    analyzedAtMs: number;
-    summary: string;
-}
-export interface ConversationVisionState {
-    backfillCompletedAtMs?: number;
-    byFileId: Record<string, ConversationVisionSummary>;
-}
-export interface ThreadConversationState {
-    compactions: ConversationCompaction[];
-    messages: ConversationMessage[];
-    processing: ConversationProcessingState;
-    schemaVersion: 1;
-    vision: ConversationVisionState;
-}
-/** Safely coerce an unknown persisted value into a ThreadConversationState. */
-export declare function coerceThreadConversationState(value: unknown): ThreadConversationState;
-/**
- * Wrap active conversation control into the thread scratch envelope.
- *
- * Visible history lives in SQL. Image summaries use a separate disposable
- * cache, so thread scratch does not retain them.
- */
-export declare function buildConversationStatePatch(conversation: ThreadConversationState): {
-    conversation: Pick<ThreadConversationState, "schemaVersion" | "processing">;
-};
-export {};

package/dist/chat/state/locks.d.ts

@@ -1,35 +0,0 @@
-import type { Lock, StateAdapter } from "chat";
-export declare const ACTIVE_LOCK_TTL_MS = 90000;
-export declare const MUTATION_LOCK_TTL_MS = 10000;
-/**
- * Acquire a lock for long-running work that the queued state adapter should
- * keep alive while the owning invocation is still making progress.
- */
-export declare function acquireActiveLock(state: StateAdapter, threadId: string): Promise<Lock | null>;
-type LockAttempt<T> = {
-    acquired: false;
-} | {
-    acquired: true;
-    value: T;
-};
-/**
- * Run work under one lock, optionally waiting for the current owner.
- * `keepAlive` is for multi-store mutations that must retain ownership until all
- * side effects finish; callers should still fence each blind write.
- */
-export declare function withLock<T>(state: StateAdapter, key: string, run: (lock: Lock) => Promise<T>, options?: {
-    keepAlive?: boolean;
-    retryMs?: number;
-    ttlMs?: number;
-    waitMs?: number;
-}): Promise<LockAttempt<T>>;
-/**
- * Prove lock ownership immediately before a blind write.
- *
- * Whole-record mutations must stop if their lock expired rather than overwrite
- * state committed by a newer owner.
- */
-export declare function fenceLock(state: StateAdapter, lock: Lock, ttlMs?: number): Promise<void>;
-/** Run work under the active lock, reporting contention without ambiguity. */
-export declare function withActiveLock<T>(state: StateAdapter, key: string, run: () => Promise<T>): Promise<LockAttempt<T>>;
-export {};

package/dist/chat/state/ttl.d.ts

@@ -1,2 +0,0 @@
-/** Retain expiring conversation/runtime state long enough for resume and dashboard history. */
-export declare const JUNIOR_THREAD_STATE_TTL_MS: number;

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

@@ -1,4 +0,0 @@
-/** Build a stable turn identifier from a message ID. */
-export declare function buildDeterministicTurnId(messageId: string): string;
-/** Build the stable visible assistant-message identity for one logical turn. */
-export declare function buildDeterministicAssistantMessageId(turnId: string): string;

package/dist/chat/task-execution/assistant-message.d.ts

@@ -1,32 +0,0 @@
-import type { AssistantMessage } from "@earendil-works/pi-ai";
-import type { Location } from "@/chat/conversations/location";
-import type { ProviderConversationReference } from "@/chat/conversations/sql/bindings";
-import type { ThreadConversationState } from "@/chat/state/conversation";
-/** Facts returned after provider Delivery. */
-export type DeliveryResult = {
-    providerMessageId?: string;
-    providerConversationBindings?: ProviderConversationReference[];
-};
-/**
- * Deliver one Message through the provider that owns its Location.
- *
- * TODO(dcramer): Delete DeliveryResult and DeliverMessage after the core Turn
- * lifecycle stores completed assistant Messages and the mailbox worker can
- * accept provider Delivery directly.
- */
-export type DeliverMessage = (input: {
-    conversationId: string;
-    location: Location;
-    text: string;
-}) => Promise<DeliveryResult>;
-/** Store one assistant Message and its Agent history. */
-export declare function commitAssistantMessage(args: {
-    agentMessage?: AssistantMessage;
-    conversation: ThreadConversationState;
-    conversationId: string;
-    deliveryResult?: DeliveryResult;
-    sessionId: string;
-    source?: "slack" | "web";
-    text: string;
-    userMessageId: string;
-}): Promise<void>;

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

@@ -1,86 +0,0 @@
-/**
- * Turn checkpoint — public resume cursor for one turn.
- *
- * Part of conversation execution with mailbox + lease + worker.
- * History is SQL (`commitMessages`). This module is the only external gate
- * for turn cursor storage (`turn-cursor.ts` is internal).
- *
- * Public API:
- * - `loadTurnCheckpoint({ conversationId, turnId })`
- * - `saveTurnCheckpoint({ mode, conversationId, turnId, messages, ... })`
- * - fail / abandon / summary helpers for terminal and recovery edges
- */
-import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { Destination, Actor, Source } from "@sentry/junior-plugin-api";
-import type { PiMessage } from "@/chat/pi/messages";
-import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
-import { type AgentTurnUsage } from "@/chat/usage";
-import type { PluginTurnContext } from "@/chat/plugins/prompt";
-import { abandonTurnRecord, failTurnRecord, getTurnRecord, listTurnSummaries, recordTurnSummary, type AgentDispatchOutcome, type TurnPauseReason, type TurnRecord, type TurnSummary, type AgentTurnSurface } from "./turn-cursor";
-export type { AgentDispatchOutcome, TurnRecord, TurnSummary, AgentTurnSurface };
-export { abandonTurnRecord, failTurnRecord, getTurnRecord, listTurnSummaries, recordTurnSummary, };
-/** Loaded resume cursor. A resumed checkpoint always has its record. */
-export type TurnCheckpoint = {
-    resumed: true;
-    sliceId: number;
-    record: TurnRecord;
-} | {
-    resumed: false;
-    sliceId: 1;
-    record?: TurnRecord;
-};
-/**
- * Lifecycle fields for a checkpoint write.
- * Routing/metrics/provenance are only for SQL dual-write / resume restore.
- * Profile, reasoning, concrete model id, and skills are not checkpoint fields.
- */
-interface TurnCheckpointWrite {
-    conversationId: string;
-    turnId: string;
-    messages: PiMessage[];
-    /** Required for running/paused; optional for completed/failed (falls back to stored). */
-    sliceId?: number;
-    actor?: Actor;
-    channelName?: string;
-    destination?: Destination;
-    destinationVisibility?: ConversationPrivacy;
-    dispatchId?: string;
-    dispatchOutcome?: AgentDispatchOutcome;
-    source?: Source;
-    surface?: AgentTurnSurface;
-    turnStartMessageIndex?: number;
-    /** Tool calls charged to this turn; survives history replacement. */
-    cumulativeToolCallCount?: number;
-    trailingMessageProvenance?: ConversationMessageProvenance[];
-    turnContexts?: PluginTurnContext[];
-    durationMs?: number;
-    usage?: AgentTurnUsage;
-    errorMessage?: string;
-    resultMessageId?: string;
-}
-type ProgressCheckpointArgs = (TurnCheckpointWrite & {
-    mode: "running";
-    sliceId: number;
-}) | (TurnCheckpointWrite & {
-    mode: "paused";
-    reason: TurnPauseReason;
-    sliceId: number;
-});
-type TerminalCheckpointArgs = TurnCheckpointWrite & {
-    mode: "completed" | "failed";
-};
-/** Boundary safe to continue after auth/timeout (trim mid-assistant). */
-export declare function continuableMessages(messages: PiMessage[], fallback?: PiMessage[]): PiMessage[];
-/** Load resume cursor for one turn. */
-export declare function loadTurnCheckpoint(args: {
-    conversationId: string;
-    turnId: string;
-}): Promise<TurnCheckpoint>;
-/**
- * Save turn progress.
- *
- * - `running` / `paused`: best-effort; returns the stored record or undefined
- * - `completed` / `failed`: retries until write accepts; throws on hard failure
- */
-export declare function saveTurnCheckpoint(args: ProgressCheckpointArgs): Promise<TurnRecord | undefined>;
-export declare function saveTurnCheckpoint(args: TerminalCheckpointArgs): Promise<void>;

package/dist/chat/task-execution/conversation-turn.d.ts

@@ -1,8 +0,0 @@
-import { type DeliverMessage } from "@/chat/task-execution/assistant-message";
-import type { AgentRunner } from "@/chat/runtime/agent-runner";
-import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
-import { type MailboxTurnWork } from "@/chat/task-execution/mailbox-turn";
-/**
- * Create the shared mailbox worker for web and resource-event Turns.
- */
-export declare function createConversationTurnWorker(agentRunner: AgentRunner, deliverMessage?: DeliverMessage): (context: ConversationWorkerContext, resolved: MailboxTurnWork) => Promise<ConversationWorkerResult>;

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

@@ -1,13 +0,0 @@
-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/mailbox-input.d.ts

@@ -1,3 +0,0 @@
-import type { InboundMessage } from "@/chat/task-execution/store";
-/** Join non-empty mailbox Message text for one Turn. */
-export declare function joinMailboxText(messages: readonly InboundMessage[]): string;

package/dist/chat/task-execution/mailbox-turn.d.ts

@@ -1,52 +0,0 @@
-import { type Source } from "@sentry/junior-plugin-api";
-import { type Actor } from "@/chat/actor";
-import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { Location } from "@/chat/conversations/location";
-import type { ConversationAuthor, ConversationMessage } from "@/chat/state/conversation";
-import type { InboundMessage } from "@/chat/task-execution/store";
-import type { ConversationWorkerContext } from "@/chat/task-execution/worker";
-/** Mailbox Message with the Actor and Source facts needed to start a Turn. */
-export type MailboxTurnInput = {
-    actor: Actor;
-    author: ConversationAuthor;
-    message: InboundMessage;
-    source: Source;
-};
-/** Actor and Source facts saved for one Turn. */
-export type TurnInputFacts = Pick<MailboxTurnInput, "actor" | "author" | "source">;
-/**
- * Restore Turn input facts, with saved Message fallback for legacy cursors.
- *
- * TODO(dcramer): Remove Actor and Source reconstruction from the saved Message
- * after no deployed Turn cursor can omit either field.
- */
-export declare function turnInputFactsFromConversationMessage(message: ConversationMessage, args: {
-    conversationId: string;
-    location?: Location;
-    savedActor?: Actor;
-    savedSource?: Source;
-    visibility?: ConversationPrivacy;
-}): TurnInputFacts | undefined;
-/** Normalize the selected mailbox Source with current Conversation visibility. */
-export declare function sourceFromTurnInput(args: {
-    conversationId: string;
-    source: Source;
-    visibility?: ConversationPrivacy;
-}): Source;
-/** Return the active web Turn for one Conversation, if it has one. */
-export declare function getActiveConversationTurnId(conversationId: string): Promise<string | undefined>;
-/** Return the idle auth-paused web Turn for one Conversation. */
-export declare function getAuthPausedConversationTurnId(conversationId: string): Promise<string | undefined>;
-/** Web or resource-event mailbox work selected for one lease. */
-export type MailboxTurnWork = {
-    kind: "mailbox";
-    batch: MailboxTurnInput[];
-} | {
-    kind: "resume";
-    turnId: string;
-};
-/**
- * Select web or resource-event work from new mailbox input or a saved Turn.
- * Saved Actor data identifies a resumed resource-event Turn.
- */
-export declare function resolveMailboxTurnWork(context: ConversationWorkerContext): Promise<MailboxTurnWork | undefined>;

package/dist/chat/task-execution/paused-turn.d.ts

@@ -1,27 +0,0 @@
-import { type PausedTurnRequest } from "@/chat/task-execution/turn-wake";
-import type { AgentRunner } from "@/chat/runtime/agent-runner";
-import type { AgentRun } from "@/chat/agent/types";
-/** Runtime ports for paused turn scheduling. */
-export interface PausedTurnOptions {
-    agentRunner: AgentRunner;
-    /** Exact persisted input ids accepted while running the paused turn. */
-    inputMessageIds?: readonly string[];
-    routingContext?: Pick<AgentRun, "actor" | "credentialContext" | "dispatch" | "surface">;
-    wakePausedTurn?: (request: PausedTurnRequest) => Promise<void>;
-    scheduleSessionCompletedPluginTasks?: (params: {
-        conversationId: string;
-        sessionId: string;
-    }) => Promise<void>;
-}
-/** Per-worker controls for one paused turn. */
-export interface PausedTurnRunOptions {
-    shouldYield?: () => boolean;
-}
-/**
- * Continue one paused Slack agent run from durable conversation state.
- *
- * Returns false when the session became stale before generation began.
- */
-export declare function runPausedTurn(payload: PausedTurnRequest, options: PausedTurnOptions, runOptions?: PausedTurnRunOptions): Promise<boolean>;
-/** Resume the first valid paused Slack session for an idle conversation. */
-export declare function runNextPausedTurn(conversationId: string, options: PausedTurnOptions, runOptions?: PausedTurnRunOptions): Promise<boolean>;

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

@@ -1,17 +0,0 @@
-import { type QueueVerifyResult } from "@/chat/queue/sign";
-import { type ConversationQueueMessage } from "./queue";
-export declare const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS: number;
-export type ConversationQueueMessageVerificationResult = QueueVerifyResult<ConversationQueueMessage>;
-/** Sign a conversation queue payload before it crosses the public callback route. */
-export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): {
-    schemaVersion: 2;
-    conversationId: string;
-} & {
-    signature: string;
-    signatureVersion: "v2";
-    signedAtMs: number;
-};
-/** 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,33 +0,0 @@
-import { z } from "zod";
-export declare const CONVERSATION_QUEUE_SCHEMA_VERSION = 2;
-/** Validate the v2 conversation work hint sent through Vercel Queue. */
-export declare const conversationQueueMessageSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
-    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;
-    constructor(reason: ConversationQueueMessageRejectReason, message: string, options?: {
-        conversationId?: string;
-    });
-}
-/** 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;
-    idempotencyKey?: string;
-}
-export interface ConversationQueueSendResult {
-    messageId?: string;
-}
-/**
- * External transport for wake-up hints. Durable work stays in the mailbox;
- * transports only need to accept one hint and may return a provider message id.
- */
-export interface ConversationWorkQueue {
-    send(message: ConversationQueueMessage, options?: ConversationQueueSendOptions): Promise<ConversationQueueSendResult | void>;
-}