@sentry/junior 0.150.1 → 0.152.0

package/dist/chat/api-turns/authorization.d.ts

@@ -0,0 +1,23 @@
+import type { OAuthAuthorizationRequest } from "@/chat/oauth-authorization";
+export interface WebAuthorizationState extends OAuthAuthorizationRequest {
+    actorId: string;
+    conversationId: string;
+}
+/** Build authorization delivery for one web turn. */
+export declare function createWebAuthorization(args: {
+    actorId: string;
+    conversationId: string;
+}): {
+    createState: () => Promise<`${string}-${string}-${string}-${string}-${string}`>;
+    deliver: (request: OAuthAuthorizationRequest) => Promise<void>;
+};
+/** Read the pending authorization request for one web actor. */
+export declare function getWebAuthorization(args: {
+    actorId: string;
+    conversationId: string;
+}): Promise<WebAuthorizationState | undefined>;
+/** Remove a web authorization request after the parked turn continues. */
+export declare function deleteWebAuthorization(args: {
+    actorId: string;
+    conversationId: string;
+}): Promise<void>;

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

@@ -230,6 +230,7 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
 }, z.core.$loose>], "type">, z.ZodObject<{
     type: z.ZodLiteral<"mcp_provider_connected">;
     provider: z.ZodString;
+    credentialSubjectId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"authorization_requested">;
     kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
@@ -455,11 +456,14 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
         }, z.core.$loose>], "type">;
         sourceEventSeq: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
-}, z.core.$strict>], "type">]>;
+}, z.core.$strict>], "type">, z.ZodObject<{
+    type: z.ZodLiteral<"mcp_provider_connected_unowned">;
+    provider: z.ZodString;
+}, z.core.$strict>]>;
 /** One durable conversation event's validated data. */
 export type ConversationEventData = z.output<typeof conversationEventDataSchema>;
 /** Event type names recognized by current readers and observational queries. */
-export declare const KNOWN_CONVERSATION_EVENT_TYPES: readonly ["message", "message_updated", "user_message", "assistant_message", "tool_result", "mcp_provider_connected", "authorization_requested", "authorization_completed", "tool_execution_started", "guardian_action_reviewed", "message_handled", "messages_summarized", "turn_started", "turn_context", "structured_event", "turn_routed", "turn_completed", "turn_failed", "subagent_started", "subagent_ended", "handoff", "compaction"];
+export declare const KNOWN_CONVERSATION_EVENT_TYPES: readonly ["message", "message_updated", "user_message", "assistant_message", "tool_result", "mcp_provider_connected", "mcp_provider_connected_unowned", "authorization_requested", "authorization_completed", "tool_execution_started", "guardian_action_reviewed", "message_handled", "messages_summarized", "turn_started", "turn_context", "structured_event", "turn_routed", "turn_completed", "turn_failed", "subagent_started", "subagent_ended", "handoff", "compaction"];
 /** One known durable conversation event type name. */
 export type KnownConversationEventType = (typeof KNOWN_CONVERSATION_EVENT_TYPES)[number];
 declare const unknownConversationEventDataSchema: z.ZodObject<{
@@ -531,6 +535,7 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$loose>], "type">, z.ZodObject<{
         type: z.ZodLiteral<"mcp_provider_connected">;
         provider: z.ZodString;
+        credentialSubjectId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"authorization_requested">;
         kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
@@ -756,7 +761,10 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             }, z.core.$loose>], "type">;
             sourceEventSeq: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
-    }, z.core.$strict>], "type">]>;
+    }, z.core.$strict>], "type">, z.ZodObject<{
+        type: z.ZodLiteral<"mcp_provider_connected_unowned">;
+        provider: z.ZodString;
+    }, z.core.$strict>]>;
 }, z.core.$strict>, z.ZodObject<{
     schemaVersion: z.ZodNumber;
     seq: z.ZodNumber;
@@ -855,6 +863,7 @@ export declare const newConversationEventSchema: z.ZodObject<{
     }, z.core.$loose>], "type">, z.ZodObject<{
         type: z.ZodLiteral<"mcp_provider_connected">;
         provider: z.ZodString;
+        credentialSubjectId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"authorization_requested">;
         kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;

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

@@ -39,8 +39,11 @@ export declare function loadTurnProjection(args: {
     committedSeq: number;
     includeTail: boolean;
 }): Promise<PiConversationEventProjection | undefined>;
-/** Load MCP providers connected in the current agent-history version. */
-export declare function loadConnectedMcpProviders(args: ScopedConversation): Promise<string[]>;
+/** 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.
  *
@@ -90,10 +93,11 @@ export declare function commitAcceptedReply(args: {
     providerConversationBindings?: Array<Omit<ProviderConversationBinding, "conversationId">>;
     repliedAtMs?: number;
 }): Promise<void>;
-/** Record a successful MCP provider connection without duplicating the fact. */
+/** 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: {

package/dist/chat/mcp/tool-manager.d.ts

@@ -10,7 +10,6 @@ import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import { type PluginMcpToolResult, type ToolAnnotations } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { SkillMetadata } from "@/chat/skills";
 import type { PluginDefinition } from "@/chat/plugins/types";
 import { McpAuthorizationRequiredError } from "./client";
 export interface McpToolSuccessHookInput {
@@ -50,7 +49,6 @@ export interface ManagedMcpToolDescriptor {
     annotations?: ToolAnnotations;
     provider: string;
 }
-type ActiveMcpSkill = Pick<SkillMetadata, "name" | "pluginProvider">;
 export interface ManagedMcpTool extends ManagedMcpToolDescriptor {
     execute: (args: Record<string, unknown>, options?: {
         conversationPrivacy?: ConversationPrivacy;
@@ -73,7 +71,6 @@ export declare class McpToolManager {
         description: string;
         active: boolean;
     }>;
-    activateForSkill(skill: ActiveMcpSkill): Promise<boolean>;
     activateProvider(provider: string): Promise<boolean>;
     close(): Promise<void>;
     /** Return descriptors for all active MCP provider tools, optionally filtered by provider. */
@@ -96,4 +93,3 @@ export declare class McpToolManager {
     }): Promise<PluginMcpToolResult>;
     private toToolDescriptor;
 }
-export {};

package/dist/chat/runtime/agent-run-outcome.d.ts

@@ -8,11 +8,15 @@ import type { AgentTurnUsage } from "@/chat/usage";
  * the session record's optimistic-concurrency version. `awaiting_auth` means
  * the run parked for user authorization.
  */
+/** Why a run parked at a safe boundary and may continue. */
+export type AgentSuspensionReason = "timeout" | "yield" | "retry";
 export type AgentRunOutcome = {
     status: "completed";
     result: AgentRunResult;
 } | {
     status: "suspended";
+    /** Why this slice stopped. Callers use this to choose wake vs yield. */
+    reason: AgentSuspensionReason;
     resumeVersion: number;
     usage?: AgentTurnUsage;
 } | {

package/dist/chat/tools/search-conversation-events.d.ts

@@ -9,7 +9,7 @@ export declare function createSearchConversationEventsTool(context: ToolRuntimeC
         after_seq?: number | null | undefined;
         before_seq?: number | null | undefined;
         limit?: number | null | undefined;
-        types?: ("message" | "message_handled" | "assistant_message" | "turn_routed" | "guardian_action_reviewed" | "turn_context" | "structured_event" | "compaction" | "handoff" | "user_message" | "tool_result" | "mcp_provider_connected" | "authorization_requested" | "authorization_completed" | "tool_execution_started" | "message_updated" | "messages_summarized" | "turn_started" | "turn_completed" | "turn_failed" | "subagent_started" | "subagent_ended")[] | null | undefined;
+        types?: ("message" | "message_handled" | "assistant_message" | "turn_routed" | "guardian_action_reviewed" | "turn_context" | "structured_event" | "compaction" | "handoff" | "user_message" | "tool_result" | "mcp_provider_connected" | "mcp_provider_connected_unowned" | "authorization_requested" | "authorization_completed" | "tool_execution_started" | "message_updated" | "messages_summarized" | "turn_started" | "turn_completed" | "turn_failed" | "subagent_started" | "subagent_ended")[] | null | undefined;
     };
     execute?: ((input: unknown, options: import("./definition").ToolExecuteOptions) => {
         [x: string]: unknown;

package/dist/chat/tools/skill/call-mcp-tool.d.ts

@@ -1,6 +1,5 @@
 import type { ManagedMcpTool } from "@/chat/mcp/tool-manager";
 interface CallMcpToolManager {
-    activateProvider(provider: string): Promise<boolean>;
     getResolvedActiveTools(): ManagedMcpTool[];
 }
 /** Create the stable dispatcher for active MCP provider tools. */

package/dist/chat/tools/skill/load-skill.d.ts

@@ -7,13 +7,10 @@ export type LoadSkillResult = {
     location?: string;
     path_resolution?: string;
     instructions?: string;
-    mcp_provider?: string;
-    available_tool_count?: number;
 } & Record<string, unknown>;
-export type LoadSkillMetadata = Pick<LoadSkillResult, "mcp_provider" | "available_tool_count">;
-/** Create the skill-loading tool that injects skill instructions and activates provider catalogs. */
+/** Create the tool that loads skill instructions for the current turn. */
 export declare function createLoadSkillTool(availableSkills: SkillMetadata[], options?: {
-    onSkillLoaded?: (skill: Skill) => void | LoadSkillMetadata | Promise<void | LoadSkillMetadata>;
+    onSkillLoaded?: (skill: Skill) => void | Promise<void>;
 }): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../definition").JsonSchemaObject;
     outputSchema: import("../definition").JsonSchemaObject;

package/dist/chat/tools/types.d.ts

@@ -4,7 +4,6 @@ import type { McpToolManager } from "@/chat/mcp/tool-manager";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import type { Skill } from "@/chat/skills";
-import type { LoadSkillMetadata } from "@/chat/tools/skill/load-skill";
 import type { JuniorToolOutput } from "@/chat/tool-support/structured-result";
 import type { WebActor, LocalActor, Actor, SlackActor } from "@/chat/actor";
 import type { SlackActionToken } from "@/chat/slack/action-token";
@@ -44,7 +43,7 @@ export interface ToolHooks {
      * generating tool reports success.
      */
     writeGeneratedArtifacts?: (files: FileUpload[]) => GeneratedArtifactFileRef[] | Promise<GeneratedArtifactFileRef[]>;
-    onSkillLoaded?: (skill: Skill) => void | LoadSkillMetadata | Promise<void | LoadSkillMetadata>;
+    onSkillLoaded?: (skill: Skill) => void | Promise<void>;
     toolOverrides?: {
         imageGenerate?: ImageGenerateToolDeps;
         viewImage?: ViewImageToolDeps;

package/dist/{chunk-2AWDPNP7.js → chunk-3PCKG4BT.js}

@@ -13,7 +13,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-GZ25ZSTX.js";
+} from "./chunk-XTLF7C4I.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   sleep
@@ -23,14 +23,14 @@ import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-B2YA2G26.js";
+} from "./chunk-X6JP6AMX.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-FGP5W3NS.js";
+} from "./chunk-OEECXAGT.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -42,7 +42,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-3WIFZBJL.js";
+} from "./chunk-7TZM33YX.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -1142,10 +1142,10 @@ function projectConversationEvents(events, options) {
 }
 
 // src/chat/conversations/projection.ts
-function connectedMcpProvidersFromEvents(events) {
+function connectedMcpProvidersFromEvents(events, credentialSubjectId) {
   const providers = /* @__PURE__ */ new Set();
   for (const event of events) {
-    if (event.data.type === "mcp_provider_connected") {
+    if (event.data.type === "mcp_provider_connected" && event.data.credentialSubjectId === credentialSubjectId) {
       providers.add(event.data.provider);
     }
   }
@@ -1285,10 +1285,10 @@ async function loadTurnProjection(args) {
   return projectConversationEvents(historyEvents);
 }
 async function loadConnectedMcpProviders(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
+  const events = await getConversationEventStore().loadHistory(
     args.conversationId
   );
-  return connectedMcpProvidersFromEvents(events);
+  return connectedMcpProvidersFromEvents(events, args.credentialSubjectId);
 }
 function messageTimestamp2(message) {
   const timestamp = message.timestamp;
@@ -1404,12 +1404,18 @@ async function commitMessagesLocked(args, executor) {
 async function recordMcpProviderConnected(args) {
   const eventStore = getConversationEventStore();
   const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (connectedMcpProvidersFromEvents(events).includes(args.provider)) {
+  if (connectedMcpProvidersFromEvents(events, args.credentialSubjectId).includes(
+    args.provider
+  )) {
     return;
   }
   await eventStore.append(args.conversationId, [
     {
-      data: { type: "mcp_provider_connected", provider: args.provider },
+      data: {
+        type: "mcp_provider_connected",
+        provider: args.provider,
+        credentialSubjectId: args.credentialSubjectId
+      },
       createdAtMs: Date.now()
     }
   ]);

package/dist/{chunk-2Z7YX5PI.js → chunk-3UJ3QYRV.js}

@@ -1,28 +1,34 @@
+import {
+  createWebAuthorization,
+  deleteWebAuthorization
+} from "./chunk-SFYDSI34.js";
 import {
   appendAndEnqueueInboundMessage
-} from "./chunk-JVOLC6JZ.js";
+} from "./chunk-AYPU5T5L.js";
 import {
   buildDeliveredTurnStatePatch,
+  completeAuthPauseTurn,
   finalizeFailedTurnReplyWithEvent,
   getTurnUserMessage,
   processPluginTask,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-N6QJAPZS.js";
+} from "./chunk-I4LR7MS2.js";
 import {
   ConversationTurnLifecycleService,
   coerceThreadConversationState,
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-JBYWR6FW.js";
+} from "./chunk-67VR4BJK.js";
 import {
   healthReportSchema
 } from "./chunk-UTL3MHPC.js";
 import {
   parseSlackThreadId
-} from "./chunk-4JV7GUUH.js";
+} from "./chunk-RCBAXKMB.js";
 import {
   TurnInputCommitLostError,
+  abandonTurnRecord,
   buildConversationContext,
   buildDeterministicTurnId,
   getAssistantReplyText,
@@ -33,6 +39,7 @@ import {
   listTurnSummaries,
   loadProjection,
   markConversationMessage,
+  markTurnClosed,
   markTurnFailed,
   normalizeConversationText,
   persistConversationMessages,
@@ -41,22 +48,26 @@ import {
   saveTurnCheckpoint,
   startActiveTurn,
   upsertConversationMessage
-} from "./chunk-2AWDPNP7.js";
+} from "./chunk-3PCKG4BT.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-D2PVJU5E.js";
+} from "./chunk-KTYC3GDO.js";
 import {
   getConversationEventStore,
   getConversationStore
-} from "./chunk-GZ25ZSTX.js";
+} from "./chunk-XTLF7C4I.js";
+import {
+  getSlackBotToken
+} from "./chunk-OEECXAGT.js";
 import {
   credentialContextForActor
 } from "./chunk-RUIXF3YQ.js";
 import {
   logException,
+  logWarn,
   setTags,
   withLogContext
-} from "./chunk-3WIFZBJL.js";
+} from "./chunk-7TZM33YX.js";
 
 // src/handlers/health.ts
 function readHealthReport() {
@@ -70,20 +81,105 @@ function GET() {
   return Response.json(readHealthReport());
 }
 
+// src/chat/slack/user.ts
+import { z } from "zod";
+var slackUserInfoSchema = z.object({
+  ok: z.literal(true),
+  user: z.object({
+    name: z.string().nullish(),
+    profile: z.object({
+      email: z.string().nullish(),
+      real_name: z.string().nullish()
+    }).optional()
+  })
+});
+var USER_CACHE_TTL_MS = 5 * 60 * 1e3;
+var userCache = /* @__PURE__ */ new Map();
+function userCacheKey(teamId, userId) {
+  return `${teamId}:${userId}`;
+}
+function readFromCache(teamId, userId) {
+  const hit = userCache.get(userCacheKey(teamId, userId));
+  if (!hit) return null;
+  if (hit.expiresAt < Date.now()) {
+    userCache.delete(userCacheKey(teamId, userId));
+    return null;
+  }
+  return hit.value;
+}
+function writeToCache(teamId, userId, value) {
+  userCache.set(userCacheKey(teamId, userId), {
+    value,
+    expiresAt: Date.now() + USER_CACHE_TTL_MS
+  });
+}
+async function lookupSlackUser(teamId, userId) {
+  if (!teamId || !userId) {
+    return null;
+  }
+  const cached = readFromCache(teamId, userId);
+  if (cached) {
+    return cached;
+  }
+  const token = getSlackBotToken();
+  if (!token) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`
+        }
+      }
+    );
+    if (!response.ok) {
+      logWarn("slack.user.lookup.failed", {
+        "enduser.id": userId,
+        "app.slack.team_id": teamId,
+        "http.response.status_code": response.status
+      });
+      return null;
+    }
+    const parsed = slackUserInfoSchema.safeParse(await response.json());
+    if (!parsed.success) {
+      return null;
+    }
+    const payload = parsed.data;
+    const userName = payload.user.name?.trim() || void 0;
+    const fullName = payload.user.profile?.real_name?.trim() || void 0;
+    const result = {
+      userName,
+      fullName,
+      email: payload.user.profile?.email?.trim() || void 0
+    };
+    writeToCache(teamId, userId, result);
+    return result;
+  } catch (error) {
+    logWarn("slack.user.lookup.failed", {
+      "enduser.id": userId,
+      "app.slack.team_id": teamId,
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+
 // src/chat/api-turns/work.ts
 import { createHash } from "crypto";
-import { z } from "zod";
+import { z as z2 } from "zod";
 import {
   createWebSource,
   localDestinationSchema
 } from "@sentry/junior-plugin-api";
-var apiTurnMailboxMetadataSchema = z.object({
-  authorEmail: z.string().email(),
-  authorFullName: z.string().min(1).optional(),
-  authorUserId: z.string().min(1),
-  authorUserName: z.string().min(1).optional(),
-  kind: z.literal("api_turn"),
-  messageId: z.string().min(1)
+var apiTurnMailboxMetadataSchema = z2.object({
+  authorEmail: z2.string().email(),
+  authorFullName: z2.string().min(1).optional(),
+  authorUserId: z2.string().min(1),
+  authorUserName: z2.string().min(1).optional(),
+  kind: z2.literal("api_turn"),
+  messageId: z2.string().min(1)
 }).strict();
 function normalizeEmail(email) {
   return email.trim().toLowerCase();
@@ -438,6 +534,27 @@ function createApiTurnWorker(options) {
           startedAtMs = userMessage.createdAtMs;
           inputMessageIds = [userMessageId];
         } else {
+          const authParked = (await listTurnSummaries(context.conversationId)).filter(
+            (summary) => summary.surface === "api" && !summary.dispatchId && summary.state === "paused" && summary.resumeReason === "auth"
+          );
+          for (const parked of authParked) {
+            await abandonTurnRecord({
+              conversationId: context.conversationId,
+              turnId: parked.turnId,
+              errorMessage: "Auth-parked session superseded by a new user message"
+            });
+            markTurnClosed({
+              conversation,
+              nowMs: Date.now(),
+              sessionId: parked.turnId
+            });
+          }
+          if (authParked.length > 0) {
+            await deleteWebAuthorization({
+              actorId: actor.userId,
+              conversationId: context.conversationId
+            });
+          }
           upsertConversationMessage(conversation, {
             id: userMessageId,
             role: "user",
@@ -535,7 +652,10 @@ function createApiTurnWorker(options) {
             publishExternally: false,
             source,
             surface: "api",
-            disabledFeatures: ["interactive-auth"],
+            authorization: createWebAuthorization({
+              actorId: actor.userId,
+              conversationId: context.conversationId
+            }),
             state: {
               pendingAuth: conversation.processing.pendingAuth,
               sandboxRef
@@ -550,14 +670,30 @@ function createApiTurnWorker(options) {
                   conversation,
                   sandboxRef
                 });
+              },
+              recordPendingAuth: async (pendingAuth) => {
+                conversation.processing.pendingAuth = pendingAuth;
+                await persistThreadStateById(context.conversationId, {
+                  conversation,
+                  sandboxRef
+                });
               }
             }
           });
           if (outcome.status === "suspended") {
             return { status: "yielded" };
           }
-          if (outcome.status !== "completed") {
-            throw new Error(`API agent run ended with ${outcome.status}`);
+          if (outcome.status === "awaiting_auth") {
+            completeAuthPauseTurn({
+              conversation,
+              sessionId: turnId
+            });
+            await persistThreadStateById(context.conversationId, {
+              conversation,
+              sandboxRef
+            });
+            await acknowledge();
+            return { status: "completed" };
           }
           reply = outcome.result;
           modelFailureCaptureAttempted = reply.diagnostics.outcome !== "success";
@@ -789,6 +925,7 @@ function formatSlackConversationRedactedLabel(context) {
 export {
   readHealthReport,
   GET,
+  lookupSlackUser,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,