@sentry/junior 0.197.0 → 0.199.0

package/dist/chat/conversations/location.d.ts

@@ -1,5 +0,0 @@
-import { locationSchema } from "@sentry/junior-plugin-api";
-import type { z } from "zod";
-export { locationSchema };
-/** Validated Location associated with a Conversation. */
-export type Location = z.output<typeof locationSchema>;

package/dist/chat/conversations/message-projection.d.ts

@@ -1,4 +0,0 @@
-import type { MessageHistory } from "./history";
-import type { ConversationMessage } from "@/chat/state/conversation";
-/** Reduce a boundary-bearing message-history suffix into destination history. */
-export declare function projectConversationMessages(history: Pick<MessageHistory, "events" | "historyFromSeq">): ConversationMessage[];

package/dist/chat/conversations/message-search.d.ts

@@ -1,38 +0,0 @@
-/** One relevant chat-message match from a prior conversation. */
-export interface ConversationMessageSearchResult {
-    channelName?: string;
-    conversationId: string;
-    excerpt: string;
-    messageCreatedAtMs: number;
-    messageId: string;
-    providerDestinationId: string;
-    role: "assistant" | "user";
-}
-/** Runtime-derived public workspace scope for cross-conversation search. */
-export interface ConversationMessageSearchScope {
-    kind: "public_provider_tenant";
-    provider: "slack";
-    providerTenantId: string;
-}
-/** Optional filters that narrow retained public workspace search. */
-export interface ConversationMessageSearchFilters {
-    /** Only conversations active at or after this time. */
-    afterMs?: number;
-    /** Annotation key, matched case-insensitively. Nested keys may continue with `#`. */
-    annotation?: string;
-    /** Only conversations active before this time. */
-    beforeMs?: number;
-    /** Slack channel id of the conversation destination. */
-    channelId?: string;
-    /** Full-text query over retained visible message text. */
-    query?: string;
-}
-/** Search retained public messages within an authorized workspace. */
-export interface ConversationMessageSearchStore {
-    search(args: {
-        currentConversationId: string;
-        filters: ConversationMessageSearchFilters;
-        limit: number;
-        scope: ConversationMessageSearchScope;
-    }): Promise<ConversationMessageSearchResult[]>;
-}

package/dist/chat/conversations/message-summaries.d.ts

@@ -1,9 +0,0 @@
-import type { ConversationEvent } from "./history";
-import type { ConversationCompaction, ThreadConversationState } from "@/chat/state/conversation";
-/** Project the latest source-message summary snapshot from event history. */
-export declare function projectConversationMessageSummaries(events: ConversationEvent[]): ConversationCompaction[];
-/** Persist a changed source-message summary snapshot in event history. */
-export declare function persistConversationMessageSummaries(args: {
-    conversation: ThreadConversationState;
-    conversationId: string;
-}): Promise<void>;

package/dist/chat/conversations/messages.d.ts

@@ -1,32 +0,0 @@
-import type { ConversationMessage, ThreadConversationState } from "@/chat/state/conversation";
-import type { ConversationEventStore } from "./history";
-/** Author role of a visible conversation message. */
-export type ConversationMessageRole = "user" | "assistant" | "system";
-/** A source message to record; identity is `(conversationId, messageId)`. */
-export interface NewConversationMessage {
-    messageId: string;
-    role: ConversationMessageRole;
-    text: string;
-    authorIdentityId?: string;
-    meta?: Record<string, unknown>;
-    createdAtMs: number;
-}
-/** Serialize one in-memory message into its event-backed write shape. */
-export declare function toStoredConversationMessage(message: ConversationMessage): NewConversationMessage;
-/** Hydrate the current message working set from canonical conversation events. */
-export declare function hydrateConversationMessages(args: {
-    conversation: ThreadConversationState;
-    conversationId: string | undefined;
-}): Promise<void>;
-/** Append new messages and handled markers idempotently. */
-export declare function persistConversationMessages(args: {
-    conversation: ThreadConversationState;
-    conversationId: string | undefined;
-    repliedAtMs?: number;
-}): Promise<void>;
-/** Append visible message facts through a caller-owned event-store transaction. */
-export declare function appendConversationMessages(eventStore: ConversationEventStore, args: {
-    conversation: ThreadConversationState;
-    conversationId: string;
-    repliedAtMs?: number;
-}): Promise<void>;

package/dist/chat/conversations/projection.d.ts

@@ -1,199 +0,0 @@
-import { type PiMessage } from "@/chat/pi/messages";
-import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
-import type { AuthorizationKind, ConversationEvent } from "@/chat/conversations/history";
-import type { RepositoryInstructions } from "@/chat/repository-instructions";
-import type { JuniorSqlDatabase } from "@/db/db";
-import { type ProviderConversationReference } from "@/chat/conversations/sql/bindings";
-import { type PiConversationEventProjection, type PiConversationProjection } from "@/chat/pi/conversation-events";
-import type { ModelProfile } from "@/chat/model-profile";
-import type { TurnReasoningLevel } from "@/chat/reasoning-level";
-import type { PluginTurnContext } from "@/chat/plugins/prompt";
-import type { ThreadConversationState } from "@/chat/state/conversation";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
-/** A checkpoint tried to replace already committed agent history. */
-export declare class AgentHistoryBranchError extends Error {
-    constructor(conversationId: string);
-}
-interface ScopedConversation {
-    conversationId: string;
-}
-/** Load the current Pi agent history for a conversation. */
-export declare function loadProjection(args: ScopedConversation): Promise<PiMessage[]>;
-/** Load current Pi context with aligned provenance and source event sequences. */
-export declare function loadConversationProjection(args: ScopedConversation): Promise<PiConversationEventProjection>;
-/** Load the active Pi projection before a conversation's next request. */
-export declare function openConversationProjection(args: ScopedConversation): Promise<PiConversationProjection>;
-/**
- * Load a turn's committed Pi projection from the durable event store.
- *
- * The record stays pinned to the history version containing its committed
- * boundary, so later compaction cannot rewrite what a stale record resumes
- * from. Unfinished records (`includeTail`) also see that version's tail so
- * parked input appended after the last safe boundary is model-visible. Terminal records
- * reproduce exactly the boundary they committed by cutting at `committedSeq`.
- * Returns undefined when the committed boundary no longer exists (purged
- * history) so callers fail closed.
- */
-export declare function loadTurnProjection(args: {
-    conversationId: string;
-    committedSeq: number;
-    includeTail: boolean;
-}): Promise<PiConversationEventProjection | undefined>;
-/** Load MCP providers the credential subject connected in this conversation. */
-export declare function loadConnectedMcpProviders(args: {
-    conversationId: string;
-    credentialSubjectId: string;
-}): Promise<string[]>;
-/**
- * Append newly stable native history items.
- *
- * Checkpoints are append-only against the durable identity of the committed
- * prefix (role, timestamp, content; tool results also match call id). A shorter
- * history or a true content branch is rejected — only compaction and handoff may
- * intentionally replace active model history. In-place Pi mutations of already
- * committed assistant envelopes (usage/stopReason) do not block the suffix.
- */
-export declare function commitMessages(args: {
-    conversationId: string;
-    messages: PiMessage[];
-    /** Explicit per-message provenance aligned one-to-one with `messages`. */
-    provenance?: ConversationMessageProvenance[];
-    /** Explicit provenance for the trailing newly committed messages. */
-    trailingMessageProvenance?: ConversationMessageProvenance[];
-    /** Default applied to the last new user message when no explicit array. */
-    newMessageProvenance?: ConversationMessageProvenance;
-    /** Structured plugin context committed atomically with this turn's input. */
-    turnContext?: {
-        contexts: PluginTurnContext[];
-        turnId: string;
-    };
-    /** SQL authority for the atomic commit; defaults to the process executor. */
-    executor?: JuniorSqlDatabase;
-}): Promise<{
-    committedSeq: number;
-    historyVersion: number;
-    /** Event sequence for every projected agent history item. */
-    messageSeqs: number[];
-    /** Normalized durable messages after volatile runtime context is removed. */
-    messages: PiMessage[];
-    provenance: ConversationMessageProvenance[];
-}>;
-/**
- * Commit an accepted agent reply and its visible message in causal order.
- *
- * The destination has already accepted the reply. One transaction prevents
- * reporting from observing the visible reply before the agent message that
- * produced it.
- */
-export declare function commitAcceptedReply(args: {
-    agentMessage?: AssistantMessage;
-    conversation: ThreadConversationState;
-    conversationMessageId: string;
-    conversationId: string;
-    providerConversationBindings?: ProviderConversationReference[];
-    repliedAtMs?: number;
-}): Promise<void>;
-/** Record a successful MCP provider connection for one credential subject without duplicating it. */
-export declare function recordMcpProviderConnected(args: {
-    conversationId: string;
-    provider: string;
-    credentialSubjectId: string;
-}): Promise<void>;
-/** Record that an OAuth/MCP authorization link was delivered or reused. */
-export declare function recordAuthorizationRequested(args: {
-    conversationId: string;
-    kind: AuthorizationKind;
-    provider: string;
-    actorId: string;
-    authorizationId: string;
-    delivery: "private_link_sent" | "private_link_reused";
-}): Promise<void>;
-/** Record completed authorization as a chronological host observation for Pi. */
-export declare function recordAuthorizationCompleted(args: {
-    conversationId: string;
-    kind: AuthorizationKind;
-    provider: string;
-    actorId: string;
-    authorizationId: string;
-}): Promise<void>;
-type AuthenticationAccountChangeArgs = {
-    accountLabel?: string;
-    actorId: string;
-    authorizationId?: string;
-    conversationId: string;
-    provider: string;
-    providerLabel?: string;
-    turnId?: string;
-};
-/** Record a successful conversation-bound account link as host transcript metadata. */
-export declare function recordAuthenticationLinked(args: AuthenticationAccountChangeArgs): Promise<void>;
-/** Record a successful conversation-bound account unlink as host transcript metadata. */
-export declare function recordAuthenticationUnlinked(args: AuthenticationAccountChangeArgs): Promise<void>;
-type AgentsInstructionsTransitionArgs = {
-    conversationId: string;
-    instructions?: RepositoryInstructions;
-    turnId: string;
-};
-/** Record one AGENTS.md bootstrap transition as host transcript metadata. */
-export declare function recordAgentsInstructionsUpdated(args: AgentsInstructionsTransitionArgs): Promise<void>;
-/** Record a model-backed subscribed reply route, including no-reply outcomes. */
-export declare function recordSubscribedReplyRoute(args: {
-    conversationId: string;
-    costUsd: number;
-    reason: string;
-    runId: string;
-    shouldReply: boolean;
-    shouldUnsubscribe?: boolean;
-}): Promise<void>;
-/** Load a previously selected model profile for a resumed turn. */
-export declare function loadTurnRoute(args: {
-    conversationId: string;
-    turnId: string;
-}): Promise<(Extract<ConversationEvent["data"], {
-    type: "turn_routed";
-}> & {
-    seq: number;
-}) | undefined>;
-/** Record the model profile selected for one turn without changing agent history. */
-export declare function recordTurnRoute(args: {
-    conversationId: string;
-    turnId: string;
-    modelProfile: ModelProfile;
-    modelId: string;
-    costUsd?: number;
-    reasoningLevel: TurnReasoningLevel;
-    confidence?: number;
-    source: "configured" | "inherited" | "router";
-}): Promise<void>;
-/** Record a host-observed parent tool start without adding it to Pi replay. */
-export declare function recordToolExecutionStarted(args: {
-    conversationId: string;
-    createdAtMs?: number;
-    toolCallId: string;
-    toolName: string;
-}): Promise<void>;
-/** Record files delivered for humans without adding them to Pi replay. */
-export declare function recordAttachmentsDelivered(args: {
-    attachments: Array<{
-        bytes: number;
-        contentType: string;
-        filename: string;
-        id: string;
-    }>;
-    conversationId: string;
-    createdAtMs?: number;
-    toolCallId?: string;
-    turnId?: string;
-}): Promise<void>;
-/** Record one privacy-safe Guardian decision before the reviewed action continues. */
-export declare function recordGuardianActionReviewed(args: {
-    conversationId: string;
-    turnId: string;
-    toolCallId: string;
-    toolName: string;
-    costUsd?: number;
-    decision: "allow" | "ask" | "deny";
-    riskLevel: "low" | "medium" | "high" | "critical";
-    userAuthorization: "high" | "medium" | "low" | "unknown";
-}): Promise<void>;
-export {};

package/dist/chat/conversations/provenance.d.ts

@@ -1,50 +0,0 @@
-/**
- * Durable message attribution shared by storage and projections.
- * Attribution never grants credential authority.
- */
-import { type Actor } from "@sentry/junior-plugin-api";
-import { z } from "zod";
-declare const conversationMessageAuthoritySchema: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
-/** Canonical authority and actor metadata for one durable message event. */
-export declare const conversationMessageProvenanceSchema: z.ZodObject<{
-    authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
-    actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        platform: z.ZodLiteral<"slack">;
-        teamId: z.ZodString;
-        email: z.ZodOptional<z.ZodString>;
-        fullName: z.ZodOptional<z.ZodString>;
-        userId: z.ZodString;
-        userName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        platform: z.ZodLiteral<"local">;
-        email: z.ZodOptional<z.ZodString>;
-        fullName: z.ZodOptional<z.ZodString>;
-        userId: z.ZodString;
-        userName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        platform: z.ZodLiteral<"web">;
-        email: z.ZodOptional<z.ZodString>;
-        fullName: z.ZodOptional<z.ZodString>;
-        userId: z.ZodString;
-        userName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        platform: z.ZodLiteral<"system">;
-        name: z.ZodString;
-    }, z.core.$strict>], "platform">>;
-}, z.core.$strict>;
-/** Whether a message is a durable instruction or ambient conversation context. */
-export type ConversationMessageAuthority = z.output<typeof conversationMessageAuthoritySchema>;
-/** Actor and authority metadata aligned with one durable message event. */
-export type ConversationMessageProvenance = z.output<typeof conversationMessageProvenanceSchema>;
-/** Build instruction provenance for an optional actor. */
-export declare function instructionProvenanceFor(actor: Actor | undefined): ConversationMessageProvenance;
-/** Unattributed ambient-context provenance for non-instruction messages. */
-export declare const contextProvenance: ConversationMessageProvenance;
-/** Compare two actors by runtime identity only, never by display metadata. */
-export declare function sameActorIdentity(left: Actor | undefined, right: Actor | undefined): boolean;
-/**
- * Return distinct instruction actors in first-seen order for attribution only.
- * Never use this list as credential authority.
- */
-export declare function instructionActors(provenance: ConversationMessageProvenance[]): Actor[];
-export {};

package/dist/chat/conversations/retention.d.ts

@@ -1,40 +0,0 @@
-import type { AttachmentStorage } from "@/chat/attachments/storage";
-import type { JuniorSqlDatabase } from "@/db/db";
-/** Content retention windows keyed by resolved conversation visibility. */
-export declare const CONTENT_RETENTION_MS: {
-    readonly public: number;
-    readonly private: number;
-};
-/** Aggregate outcome of one bounded retention purge batch. */
-export interface RetentionPurgeResult {
-    /** Attachment blobs removed after conversation content was purged. */
-    attachments: number;
-    /** Root conversations examined and attempted this run. */
-    scanned: number;
-    /** Root trees successfully purged. */
-    purged: number;
-    /** Root trees whose purge failed and were skipped. */
-    failed: number;
-    /** Total conversation rows (roots plus descendants) stamped by the purge. */
-    conversations: number;
-}
-/**
- * Run one bounded retention purge batch: delete expired root conversation trees
- * oldest-activity-first. Each tree is purged transactionally in isolation, so a
- * single failing tree is logged and skipped without aborting the batch, and the
- * remainder of an over-limit backlog is left for the next run.
- */
-export declare function runRetentionPurge(executor: JuniorSqlDatabase, args: {
-    attachmentStorage?: AttachmentStorage;
-    nowMs: number;
-    limit?: number;
-}): Promise<RetentionPurgeResult>;
-/**
- * Erase one conversation's content and descendants immediately, regardless of
- * age, applying the same visibility-based metadata scrubbing as the purge job.
- * The scrub decision uses the root's resolved visibility so erasing a child
- * still fails closed to private for a private root.
- */
-export declare function purgeConversation(executor: JuniorSqlDatabase, conversationId: string, opts?: {
-    nowMs?: number;
-}): Promise<void>;

package/dist/chat/conversations/sql/actor-identity.d.ts

@@ -1,19 +0,0 @@
-import type { StoredSlackActor } from "@/chat/actor";
-import type { IdentityUpsert } from "@/chat/identities/identity";
-import type { Conversation, ConversationSource } from "../store";
-import type { juniorIdentities } from "@/db/schema";
-type IdentityRow = typeof juniorIdentities.$inferSelect;
-/** Build a durable identity observation from a stored conversation actor. */
-export declare function identityFromActor(actor: StoredSlackActor | undefined): IdentityUpsert | undefined;
-/** Build a system identity when a conversation has no user actor. */
-export declare function systemIdentityFromSource(source: ConversationSource | undefined): IdentityUpsert | undefined;
-/** Prefer the user actor identity, else a source-derived system identity. */
-export declare function actorIdentityForConversation(conversation: Conversation): IdentityUpsert | undefined;
-/**
- * Reconstruct a stored actor with the linked user name and identity-scoped
- * provider fields.
- */
-export declare function actorFromIdentityRow(identity: IdentityRow | null, userDisplayName: string | null): StoredSlackActor | undefined;
-/** Merge later actor observations without replacing a durable Slack subject. */
-export declare function mergeActor(current: StoredSlackActor | undefined, next: StoredSlackActor | undefined): StoredSlackActor | undefined;
-export {};

package/dist/chat/conversations/sql/bindings.d.ts

@@ -1,13 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-export interface ProviderConversationBinding {
-    conversationId: string;
-    provider: string;
-    providerDestinationId: string;
-    providerTenantId: string;
-    providerConversationId: string;
-}
-export type ProviderConversationReference = Omit<ProviderConversationBinding, "conversationId">;
-/** Resolve the durable conversation bound to provider-owned coordinates. */
-export declare function getConversationIdByProviderConversation(executor: JuniorSqlDatabase, args: ProviderConversationReference): Promise<string | undefined>;
-/** Bind provider coordinates to a durable conversation in the caller's SQL scope. */
-export declare function bindProviderConversation(executor: JuniorSqlDatabase, args: ProviderConversationBinding): Promise<void>;

package/dist/chat/conversations/sql/conversation-row.d.ts

@@ -1,17 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-/**
- * Establish the conversation metadata row on first contact for content writes
- * (conversation events, visible transcript) that can land before activity has
- * created the row, and whose tables FK to it.
- *
- * First contact creates the row; every later content write advances the
- * activity clock so retention mirrors append-refresh semantics (each content
- * append refreshes the retention window). Background observations may opt out
- * and leave an existing row unchanged. The timestamp is content-intrinsic (the
- * first item's `createdAtMs`), and `greatest(...)` guarantees a backfilled or
- * imported historical write — which carries an old timestamp — can never
- * regress `last_activity_at`.
- */
-export declare function ensureConversationRow(executor: JuniorSqlDatabase, conversationId: string, atMs: number, options?: {
-    activity?: "preserve";
-}): Promise<void>;

package/dist/chat/conversations/sql/event-actor.d.ts

@@ -1,14 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-import type { ConversationEventData } from "../history";
-/**
- * Resolve the durable actor identity for one event payload.
- * Human user messages get an identity when author data is enough; other events
- * keep a null actor.
- */
-export declare function resolveEventActorIdentityId(executor: JuniorSqlDatabase, args: {
-    conversationId: string;
-    data: ConversationEventData;
-    nowMs: number;
-}): Promise<string | undefined>;
-/** Drop payload-only authorIdentityId after lifting it onto the event column. */
-export declare function stripPayloadAuthorIdentityId(data: ConversationEventData): ConversationEventData;

package/dist/chat/conversations/sql/event-lock.d.ts

@@ -1,3 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-/** Serialize event sequence allocation with other conversation writes. */
-export declare function withConversationEventLock<T>(executor: JuniorSqlDatabase, conversationId: string, callback: () => Promise<T>): Promise<T>;

package/dist/chat/conversations/sql/history.d.ts

@@ -1,4 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-import { type ConversationEventStore } from "../history";
-/** Create a SQL-backed canonical conversation event store. */
-export declare function createSqlConversationEventStore(executor: JuniorSqlDatabase): ConversationEventStore;

package/dist/chat/conversations/sql/location.d.ts

@@ -1,18 +0,0 @@
-import type { Destination } from "@sentry/junior-plugin-api";
-import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import { type Location } from "@/chat/conversations/location";
-import type { SessionSource } from "@/chat/source";
-import type { juniorDestinations } from "@/db/schema";
-type LocationRow = typeof juniorDestinations.$inferSelect;
-/** Build the complete Location for one Conversation SQL write. */
-export declare function locationForWrite(args: {
-    destination: Destination | undefined;
-    destinationId: string | undefined;
-    location: Location | undefined;
-    sessionSource: SessionSource | undefined;
-}): Location | undefined;
-/** Read one complete Location from SQL. */
-export declare function locationFromRow(value: unknown, row: LocationRow | null, sessionSource: SessionSource | undefined): Location | undefined;
-/** Read confirmed visibility from one linked Location row. */
-export declare function visibilityFromLocationRow(row: LocationRow | null): ConversationPrivacy | undefined;
-export {};

package/dist/chat/conversations/sql/message-search.d.ts

@@ -1,4 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-import type { ConversationMessageSearchStore } from "../message-search";
-/** Create a SQL-backed public workspace message search store. */
-export declare function createSqlConversationMessageSearchStore(executor: JuniorSqlDatabase): ConversationMessageSearchStore;

package/dist/chat/conversations/sql/participants.d.ts

@@ -1,18 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-/** Resolve the root conversation id that owns personal-feed membership. */
-export declare function resolveRootConversationId(executor: JuniorSqlDatabase, conversationId: string): Promise<string>;
-/**
- * Upsert one linked user as a participant on a root conversation.
- * No-ops when the identity is missing, unlinked, or not a user.
- */
-export declare function recordConversationParticipant(executor: JuniorSqlDatabase, args: {
-    actorIdentityId: string;
-    conversationId: string;
-    atMs: number;
-    restoreArchive?: boolean;
-}): Promise<void>;
-/** Find which of the supplied root conversations include the linked user. */
-export declare function rootConversationIdsForParticipant(executor: JuniorSqlDatabase, args: {
-    rootConversationIds: readonly string[];
-    userId: string;
-}): Promise<Set<string>>;

package/dist/chat/conversations/sql/privacy.d.ts

@@ -1,15 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-import type { JuniorDestinationVisibility } from "@/db/schema/destinations";
-/** Root conversation identity and its normalized destination visibility. */
-export interface RootConversationVisibility {
-    rootConversationId: string;
-    visibility: JuniorDestinationVisibility | null;
-}
-/**
- * Resolve a conversation's privacy authority from its persisted root.
- *
- * Missing or structurally invalid root metadata fails closed. The root
- * destination is locked so callers that keep the transaction open receive a
- * stable visibility decision.
- */
-export declare function resolveRootVisibility(executor: JuniorSqlDatabase, conversationId: string): Promise<RootConversationVisibility>;

package/dist/chat/conversations/sql/purge.d.ts

@@ -1,45 +0,0 @@
-import type { JuniorSqlDatabase } from "@/db/db";
-import type { JuniorDestinationVisibility } from "@/db/schema/destinations";
-/** An expired root conversation selected for purge, with its resolved visibility. */
-export interface ExpiredRoot {
-    conversationId: string;
-    visibility: JuniorDestinationVisibility | null;
-}
-/** Outcome of purging one conversation tree. */
-export interface PurgeTreeResult {
-    /** Whether this transaction still found the root eligible for purge. */
-    purged: boolean;
-    /** Root plus descendant conversation rows stamped by the purge. */
-    conversations: number;
-}
-/**
- * Select expired root conversations for purge, oldest activity first.
- *
- * Roots have no parent, so visibility is read directly from the root's own
- * destination; the private window applies to every non-`public` case. A row is
- * skipped once it is fully purged — no content rows survive and no non-public
- * scrub fields remain — so a bounded batch spends its budget on real work.
- */
-export declare function selectExpiredRoots(executor: JuniorSqlDatabase, args: {
-    nowMs: number;
-    publicWindowMs: number;
-    privateWindowMs: number;
-    limit: number;
-}): Promise<ExpiredRoot[]>;
-/**
- * Purge one conversation tree in a single transaction: delete all message and
- * event rows for the given conversation and every descendant, stamp
- * `transcript_purged_at`, and — for non-public content — null the raw-payload
- * metadata (`title`, `channel_name`, legacy actor JSON) so purged private
- * conversations keep only safe metadata. The metadata rows themselves survive.
- */
-export declare function purgeConversationTree(executor: JuniorSqlDatabase, args: {
-    rootConversationId: string;
-    scrubMetadata?: boolean;
-    scrubMetadataFromRootVisibility?: boolean;
-    nowMs: number;
-    retention?: {
-        privateWindowMs: number;
-        publicWindowMs: number;
-    };
-}): Promise<PurgeTreeResult>;

package/dist/chat/conversations/sql/store.d.ts

@@ -1,77 +0,0 @@
-import type { Destination, Source } from "@sentry/junior-plugin-api";
-import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { StoredSlackActor } from "@/chat/actor";
-import type { JuniorSqlDatabase } from "@/db/db";
-import type { Conversation, ConversationExecution, ConversationSource, ConversationStore } from "../store";
-import type { AgentTurnUsage } from "@/chat/usage";
-import { type ProviderConversationBinding, type ProviderConversationReference } from "./bindings";
-/** Serialize one conversation's durable mutations inside a SQL transaction. */
-export declare function withConversationMutationLock<T>(executor: JuniorSqlDatabase, conversationId: string, callback: () => Promise<T>): Promise<T>;
-export declare class SqlStore implements ConversationStore {
-    private readonly executor;
-    constructor(executor: JuniorSqlDatabase);
-    getConversationIdByProviderConversation(args: ProviderConversationReference): Promise<string | undefined>;
-    bindProviderConversation(args: ProviderConversationBinding): Promise<void>;
-    createChild(args: {
-        childConversationId: string;
-        parentConversationId: string;
-        nowMs?: number;
-        source?: ConversationSource;
-    }): Promise<void>;
-    get(args: {
-        conversationId: string;
-    }): Promise<Conversation | undefined>;
-    recordActivity(args: {
-        activityAtMs?: number;
-        channelName?: string;
-        conversationId: string;
-        destination?: Destination;
-        nowMs?: number;
-        actor?: StoredSlackActor;
-        source?: ConversationSource;
-        sessionSource?: Source;
-        title?: string;
-        visibility?: ConversationPrivacy;
-    }): Promise<void>;
-    recordExecution(args: {
-        channelName?: string;
-        conversationId: string;
-        createdAtMs: number;
-        destination?: Destination;
-        execution: ConversationExecution;
-        lastActivityAtMs: number;
-        metrics: {
-            durationMs: number;
-            usage?: AgentTurnUsage;
-        } | null;
-        actor?: StoredSlackActor;
-        source?: ConversationSource;
-        title?: string;
-        updatedAtMs: number;
-        visibility?: ConversationPrivacy;
-    }): Promise<void>;
-    listByActivity(args?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<Conversation[]>;
-    getDestinationVisibility(args: {
-        provider: string;
-        providerDestinationId: string;
-        providerTenantId?: string;
-    }): Promise<ConversationPrivacy | undefined>;
-    findSlackDestinationByName(args: {
-        channelName: string;
-        teamId: string;
-    }): Promise<{
-        channelId: string;
-        channelName?: string;
-    } | undefined>;
-    /** Serialize all durable mutations for one conversation inside a SQL transaction. */
-    private withConversationMutation;
-    private readConversationRow;
-    /** Upsert the conversation row while preserving previously discovered nullable metadata fields. */
-    private upsertConversation;
-    private upsertDestination;
-}
-/** Create a SQL-backed conversation store. */
-export declare function createSqlStore(executor: JuniorSqlDatabase): SqlStore;