@sentry/junior 0.72.0 → 0.74.0

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

@@ -5,9 +5,10 @@ import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { PluginDefinition } from "@/chat/plugins/types";
 export declare class McpAuthorizationPauseError extends AuthorizationPauseError {
-    constructor(provider: string, disposition: "link_already_sent" | "link_sent");
+    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/message-actor-identity.d.ts

@@ -1,5 +1,5 @@
 import type { Message } from "chat";
-import { type Requester, type SlackRequesterProfile } from "@/chat/requester";
+import { type Requester, type SlackRequester, type SlackRequesterProfile } from "@/chat/requester";
 interface MessageAuthorIdentity {
     email?: string;
     fullName?: string;
@@ -12,5 +12,5 @@ export declare function bindMessageActorIdentity(message: Message, requester: Re
 /** Read message identity without promoting adapter display fallbacks. */
 export declare function getMessageActorIdentity(message: Message): MessageActorIdentity | undefined;
 /** Attach Slack display fields only after the author id is exact. */
-export declare function ensureSlackMessageActorIdentity(message: Message, teamId: string, lookupSlackUser: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>): Promise<Requester>;
+export declare function ensureSlackMessageActorIdentity(message: Message, teamId: string, lookupSlackUser: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>): Promise<SlackRequester>;
 export {};

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

@@ -3,15 +3,15 @@ import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
-import type { Skill } from "@/chat/skills";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
-    constructor(provider: string, disposition: "link_already_sent" | "link_sent");
+    constructor(provider: string, providerDisplayName: string, disposition: "link_already_sent" | "link_sent");
 }
 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;
@@ -20,20 +20,22 @@ 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;
 }
 export interface PluginAuthOrchestration {
-    handleCommandFailure: (input: {
-        activeSkill: Skill | null;
-        command: string;
-        details: unknown;
-    }) => Promise<void>;
+    /**
+     * 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 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 an authenticated bash command 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/services/turn-result.d.ts

@@ -1,5 +1,6 @@
 import type { FileUpload } from "chat";
 import type { LogContext } from "@/chat/logging";
+import type { PiMessage } from "@/chat/pi/messages";
 import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
 import type { AgentTurnUsage } from "@/chat/usage";
 import { type ReplyDeliveryPlan } from "@/chat/services/reply-delivery-plan";
@@ -27,6 +28,7 @@ export interface AssistantReply {
     deliveryMode?: "thread" | "channel_only";
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
+    piMessages?: PiMessage[];
     diagnostics: AgentTurnDiagnostics;
 }
 export interface TurnResultInput {
@@ -37,6 +39,7 @@ export interface TurnResultInput {
     toolCalls: string[];
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
+    piMessages?: PiMessage[];
     durationMs?: number;
     generatedFileCount: number;
     shouldTrace: boolean;

package/dist/chat/slack/user.d.ts

@@ -1,4 +1,4 @@
-import { type Requester } from "@/chat/requester";
+import { type SlackRequester } from "@/chat/requester";
 interface SlackUserLookupResult {
     userName?: string;
     fullName?: string;
@@ -7,5 +7,5 @@ interface SlackUserLookupResult {
 /** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
 export declare function lookupSlackUser(teamId: string, userId?: string): Promise<SlackUserLookupResult | null>;
 /** Resolve the canonical Slack requester from Slack profile data. */
-export declare function lookupSlackRequester(teamId: string, userId: string): Promise<Requester>;
+export declare function lookupSlackRequester(teamId: string, userId: string): Promise<SlackRequester>;
 export {};

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;