@sentry/junior 0.73.0 → 0.74.1

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

@@ -0,0 +1,52 @@
+import type { Destination } from "@sentry/junior-plugin-api";
+import { type StoredSlackRequester } from "@/chat/requester";
+import type { JuniorSqlDatabase, JuniorSqlMigrationExecutor } from "@/chat/sql/db";
+import type { Conversation, ConversationExecution, ConversationSource, ConversationStore } from "../store";
+export declare class SqlStore implements ConversationStore {
+    private readonly executor;
+    private readonly migrationExecutor;
+    private schemaReady;
+    constructor(executor: JuniorSqlDatabase, migrationExecutor: JuniorSqlMigrationExecutor);
+    /** Apply SQL schema migrations before runtime uses this store. */
+    migrate(): Promise<void>;
+    get(args: {
+        conversationId: string;
+    }): Promise<Conversation | undefined>;
+    recordActivity(args: {
+        activityAtMs?: number;
+        channelName?: string;
+        conversationId: string;
+        destination?: Destination;
+        nowMs?: number;
+        requester?: StoredSlackRequester;
+        source?: ConversationSource;
+        title?: string;
+    }): Promise<void>;
+    recordExecution(args: {
+        channelName?: string;
+        conversationId: string;
+        createdAtMs: number;
+        destination?: Destination;
+        execution: ConversationExecution;
+        lastActivityAtMs: number;
+        requester?: StoredSlackRequester;
+        source?: ConversationSource;
+        title?: string;
+        updatedAtMs: number;
+    }): Promise<void>;
+    /** Copy one conversation record into SQL during backfill. */
+    backfillConversation(conversation: Conversation): Promise<void>;
+    listByActivity(args?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Conversation[]>;
+    /** 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 upsertIdentity;
+    private upsertDestination;
+}
+/** Create a SQL-backed conversation store. */
+export declare function createSqlStore(executor: JuniorSqlMigrationExecutor): SqlStore;

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

@@ -0,0 +1,4 @@
+import type { StateAdapter } from "chat";
+import type { ConversationStore } from "./store";
+/** Create the no-SQL conversation record store backed by task-execution state. */
+export declare function createStateConversationStore(state?: StateAdapter): ConversationStore;

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

@@ -0,0 +1,57 @@
+import type { Destination } from "@sentry/junior-plugin-api";
+import type { StoredSlackRequester } from "@/chat/requester";
+export type ConversationSource = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+export type ConversationStatus = "awaiting_resume" | "idle" | "pending" | "running";
+export interface ConversationExecution {
+    lastCheckpointAtMs?: number;
+    lastEnqueuedAtMs?: number;
+    runId?: string;
+    status: ConversationStatus;
+    updatedAtMs?: number;
+}
+export interface Conversation {
+    channelName?: string;
+    conversationId: string;
+    createdAtMs: number;
+    destination?: Destination;
+    execution: ConversationExecution;
+    lastActivityAtMs: number;
+    requester?: StoredSlackRequester;
+    schemaVersion: 1;
+    source?: ConversationSource;
+    title?: string;
+    updatedAtMs: number;
+}
+/** Persist and read durable conversation metadata for reporting surfaces. */
+export interface ConversationStore {
+    get(args: {
+        conversationId: string;
+    }): Promise<Conversation | undefined>;
+    recordActivity(args: {
+        activityAtMs?: number;
+        channelName?: string;
+        conversationId: string;
+        destination?: Destination;
+        nowMs?: number;
+        requester?: StoredSlackRequester;
+        source?: ConversationSource;
+        title?: string;
+    }): Promise<void>;
+    /** Store task-execution metadata for long-term conversation history. */
+    recordExecution(args: {
+        channelName?: string;
+        conversationId: string;
+        createdAtMs: number;
+        destination?: Destination;
+        execution: ConversationExecution;
+        lastActivityAtMs: number;
+        requester?: StoredSlackRequester;
+        source?: ConversationSource;
+        title?: string;
+        updatedAtMs: number;
+    }): Promise<void>;
+    listByActivity(args?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Conversation[]>;
+}

package/dist/chat/ingress/slack-webhook.d.ts

@@ -1,6 +1,7 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { type StateAdapter } from "chat";
 import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
 import type { WaitUntilFn } from "@/handlers/types";
@@ -8,6 +9,7 @@ export interface SlackWebhookServices {
     getUserTokenStore?: () => UserTokenStore;
     getSlackAdapter: () => SlackAdapter;
     queue: ConversationWorkQueue;
+    conversationStore?: ConversationStore;
     runtime: Pick<SlackTurnRuntime<unknown>, "handleAssistantContextChanged" | "handleAssistantThreadStarted" | "handleNewMention" | "handleSubscribedMessage">;
     state?: StateAdapter;
 }

package/dist/chat/plugins/agent-hooks.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPluginRoute, PluginOperationalReport, SlackConversationLink, JuniorPluginRegistration } from "@sentry/junior-plugin-api";
+import type { AgentPluginConversations, AgentPluginRoute, PluginOperationalReport, SlackConversationLink, JuniorPluginRegistration } from "@sentry/junior-plugin-api";
 import type { ToolDefinition } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
@@ -35,7 +35,7 @@ export declare function getAgentPluginRoutes(): AgentPluginRouteRegistration[];
 /** Resolve the first plugin conversation URL for finalized Slack footers. */
 export declare function getAgentPluginSlackConversationLink(conversationId: string): SlackConversationLink | undefined;
 /** Collect read-only operational summaries exposed by plugins. */
-export declare function getAgentPluginOperationalReports(nowMs?: number): Promise<PluginOperationalReport[]>;
+export declare function getAgentPluginOperationalReports(nowMs: number, conversations: AgentPluginConversations): Promise<PluginOperationalReport[]>;
 /** Create one runner over runtime hook plugins registered by the app. */
 export declare function createAgentPluginHookRunner(input?: {
     requester?: Requester;

package/dist/chat/respond.d.ts

@@ -65,7 +65,7 @@ export interface ReplyRequestContext {
     drainSteeringMessages?: (inject: (messages: ReplySteeringMessage[]) => Promise<void>) => Promise<ReplySteeringMessage[]>;
     /** Return true when the durable worker should pause at the next Pi boundary. */
     shouldYield?: () => boolean;
-    onAuthPending?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     onTextDelta?: (deltaText: string) => void | Promise<void>;
     onAssistantMessageStart?: () => void | Promise<void>;
     onToolInvocation?: (invocation: {

package/dist/chat/services/mcp-auth-orchestration.d.ts

@@ -7,7 +7,8 @@ import type { PluginDefinition } from "@/chat/plugins/types";
 export declare class McpAuthorizationPauseError extends AuthorizationPauseError {
     constructor(provider: string, providerDisplayName: string, disposition: "link_already_sent" | "link_sent");
 }
-export interface McpAuthOrchestrationDeps {
+export interface McpAuthOrchestrationInput {
+    abortAgent: () => void;
     conversationId?: string;
     sessionId?: string;
     requesterId?: string;
@@ -16,11 +17,11 @@ export interface McpAuthOrchestrationDeps {
     threadTs?: string;
     toolChannelId?: string;
     userMessage: string;
-    currentPendingAuth?: ConversationPendingAuthState;
+    pendingAuth?: ConversationPendingAuthState;
     getConfiguration: () => Record<string, unknown>;
     getArtifactState: () => ThreadArtifactsState | undefined;
     getMergedArtifactState: () => ThreadArtifactsState;
-    onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;
 }
 export interface McpAuthOrchestration {
@@ -28,5 +29,5 @@ export interface McpAuthOrchestration {
     onAuthorizationRequired: (provider: string) => Promise<boolean>;
     getPendingPause: () => McpAuthorizationPauseError | undefined;
 }
-/** Create MCP authorization orchestration for a single turn. */
-export declare function createMcpAuthOrchestration(deps: McpAuthOrchestrationDeps, abortAgent: () => void): McpAuthOrchestration;
+/** Create MCP authorization orchestration for a single agent run. */
+export declare function createMcpAuthOrchestration(input: McpAuthOrchestrationInput): McpAuthOrchestration;

package/dist/chat/services/pending-auth.d.ts

@@ -1,5 +1,6 @@
 import type { AuthorizationPauseKind } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState, ThreadConversationState } from "@/chat/state/conversation";
+/** Decide whether the same agent-run session can reuse its fresh auth link. */
 export declare function canReusePendingAuthLink(args: {
     kind: AuthorizationPauseKind;
     nowMs?: number;
@@ -7,6 +8,7 @@ export declare function canReusePendingAuthLink(args: {
     provider: string;
     requesterId: string;
     scope?: string;
+    sessionId: string;
 }): boolean;
 export declare function getConversationPendingAuth(args: {
     conversation: ThreadConversationState;

package/dist/chat/services/plugin-auth-orchestration.d.ts

@@ -10,7 +10,8 @@ export declare class PluginCredentialFailureError extends Error {
     readonly provider: string;
     constructor(provider: string, message: string);
 }
-export interface PluginAuthOrchestrationDeps {
+export interface PluginAuthOrchestrationInput {
+    abortAgent: () => void;
     conversationId?: string;
     sessionId?: string;
     requesterId?: string;
@@ -19,8 +20,8 @@ export interface PluginAuthOrchestrationDeps {
     threadTs?: string;
     userMessage: string;
     channelConfiguration?: ChannelConfigurationService;
-    currentPendingAuth?: ConversationPendingAuthState;
-    onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    pendingAuth?: ConversationPendingAuthState;
+    recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;
     userTokenStore?: UserTokenStore;
 }
@@ -28,13 +29,13 @@ export interface PluginAuthOrchestration {
     /**
      * Inspect a sandbox tool result for an `auth_required` signal from the
      * egress proxy. If one is present and an OAuth flow is available, parks the
-     * current turn and sends the user an authorization link. No-ops when the
+     * current run and sends the user an authorization link. No-ops when the
      * result carries no auth signal.
      */
     maybeHandleAuthSignal: (details: unknown) => Promise<void>;
     getPendingPause: () => PluginAuthorizationPauseError | undefined;
 }
 /**
- * Start plugin OAuth from a sandbox egress auth signal and park the turn.
+ * Start plugin OAuth from a sandbox egress auth signal and park the run.
  */
-export declare function createPluginAuthOrchestration(deps: PluginAuthOrchestrationDeps, abortAgent: () => void): PluginAuthOrchestration;
+export declare function createPluginAuthOrchestration(input: PluginAuthOrchestrationInput): PluginAuthOrchestration;

package/dist/chat/sql/db.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared Junior SQL boundary.
+ *
+ * Feature schemas compose into `juniorSqlSchema`, and feature stores should use
+ * Drizzle through `db()`. Raw SQL exists on this executor for schema migration
+ * and catalog checks only.
+ */
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
+import type { juniorSqlSchema } from "./schema";
+export type JuniorDatabase = PgDatabase<PgQueryResultHKT, typeof juniorSqlSchema>;
+export interface JuniorSqlDatabase {
+    db(): JuniorDatabase;
+    transaction<T>(callback: () => Promise<T>): Promise<T>;
+    withLock<T>(lockName: string, callback: () => Promise<T>): Promise<T>;
+}
+export interface JuniorSqlMigrationExecutor extends JuniorSqlDatabase {
+    execute(statement: string, params?: readonly unknown[]): Promise<void>;
+    query<T = unknown>(statement: string, params?: readonly unknown[]): Promise<T[]>;
+}

package/dist/chat/sql/neon.d.ts

@@ -0,0 +1,9 @@
+import type { JuniorSqlMigrationExecutor } from "./db";
+/** Neon-backed SQL executor with an owned connection pool lifecycle. */
+export interface NeonJuniorSqlExecutor extends JuniorSqlMigrationExecutor {
+    close(): Promise<void>;
+}
+/** Create the shared Neon-backed Junior SQL executor. */
+export declare function createNeonJuniorSqlExecutor(args: {
+    connectionString: string;
+}): NeonJuniorSqlExecutor;