@sentry/junior 0.179.0 → 0.180.0

package/dist/{chunk-3I7XE3PA.js → chunk-DHLOGWYH.js}

@@ -5,7 +5,7 @@ import {
   getConversationEventStore,
   getDb,
   getSqlExecutor
-} from "./chunk-VP4OVRDD.js";
+} from "./chunk-S7YRTOSQ.js";
 import {
   juniorConversationAnnotations,
   juniorConversationEvents,
@@ -14,7 +14,7 @@ import {
   juniorUsers,
   juniorWorkspaceRepos,
   juniorWorkspaces
-} from "./chunk-R6U7N4FS.js";
+} from "./chunk-FGC3PHNH.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   getVercelSandboxCredentials,
@@ -22,24 +22,24 @@ import {
   isSandboxMissingError,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-JMJNFEDC.js";
+} from "./chunk-WVAMRKYG.js";
 import {
   getStateAdapter
-} from "./chunk-3TM3FYLQ.js";
+} from "./chunk-GA5NS74S.js";
 import {
   botConfig,
   completeObject,
+  defaultModelId,
   embedTexts,
-  getSlackBotToken,
-  standardModelId
-} from "./chunk-GENV6KF2.js";
+  getSlackBotToken
+} from "./chunk-I6IFTAPF.js";
 import {
   isActorUserId,
   parseActorUserId,
   parseSlackChannelReferenceId,
   parseSlackMessageTs,
   parseSlackTeamId
-} from "./chunk-M63DETLL.js";
+} from "./chunk-N7TMSOZH.js";
 import {
   logException,
   logInfo,
@@ -48,15 +48,15 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-HQNE5APD.js";
+} from "./chunk-RAZG3YHC.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
   missingToolAnnotationKeys,
   normalizeResourceEventIdentifier,
+  pluginResourceEventsSchema,
   promptContextSchema,
   promptMessageSchema,
-  pluginResourceEventsSchema,
   resourceEventInputSchema
 } from "@sentry/junior-plugin-api";
 
@@ -300,13 +300,13 @@ function createPluginLogger(plugin) {
 function createPluginModel(pluginName, options = {}, runtime = {}) {
   return {
     async completeObject(input) {
-      const modelId = options.structuredModelId ?? (options.structuredModel === "default" ? standardModelId(botConfig) : botConfig.fastModelId);
+      const modelId = options.structuredModelId ?? (options.structuredModel === "default" ? defaultModelId(botConfig) : botConfig.fastModelId);
       const result = await completeObject({
         modelId,
         schema: input.schema,
         prompt: input.prompt,
-        ...input.system !== void 0 ? { system: input.system } : {},
-        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
+        ...input.system !== void 0 ? { system: input.system } : void 0,
+        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : void 0,
         signal: runtime.signal,
         promptName: `${pluginName}.structured_completion`,
         metadata: {
@@ -316,7 +316,7 @@ function createPluginModel(pluginName, options = {}, runtime = {}) {
       });
       return {
         object: result.object,
-        ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : {}
+        ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0
       };
     }
   };
@@ -766,7 +766,7 @@ async function withSlackRetries(task, maxAttempts = 3, context = {}) {
           "url.path": `/api/${action}`,
           "app.slack.method": action,
           "app.retry.max_attempts": maxAttempts,
-          ...attemptNumber > 1 ? { "http.request.resend_count": attemptNumber - 1 } : {},
+          ...attemptNumber > 1 ? { "http.request.resend_count": attemptNumber - 1 } : void 0,
           ...context.attributes ?? {},
           ...context.spanAttributes ?? {}
         }
@@ -779,18 +779,18 @@ async function withSlackRetries(task, maxAttempts = 3, context = {}) {
       const baseLogAttributes = {
         "app.slack.action": action,
         "app.slack.error_code": mapped.code,
-        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
-        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
-        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
-        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
-        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
-        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
+        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : void 0,
+        ...mapped.detail ? { "app.slack.detail": mapped.detail } : void 0,
+        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : void 0,
+        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : void 0,
+        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : void 0,
+        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : void 0,
         ...context.attributes ?? {}
       };
       if (!isRetryable || attempt >= maxAttempts || remainingDelayBudgetMs <= 0) {
         logWarn("slack.action.failed", {
           ...baseLogAttributes,
-          ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
+          ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : void 0
         });
         throw mapped;
       }
@@ -1381,9 +1381,9 @@ function identityFromRow(row) {
     id: row.id,
     provider: row.provider,
     providerSubjectId: row.providerSubjectId,
-    ...row.providerTenantId ? { providerTenantId: row.providerTenantId } : {},
-    ...row.displayName ? { displayName: row.displayName } : {},
-    ...row.handle ? { handle: row.handle } : {}
+    ...row.providerTenantId ? { providerTenantId: row.providerTenantId } : void 0,
+    ...row.displayName ? { displayName: row.displayName } : void 0,
+    ...row.handle ? { handle: row.handle } : void 0
   });
 }
 async function readUserById(db, userRow) {
@@ -1401,7 +1401,7 @@ async function readUserById(db, userRow) {
     email: userRow.primaryEmail,
     id: userRow.id,
     identities: identityRows.map(identityFromRow),
-    ...userRow.displayName ? { displayName: userRow.displayName } : {}
+    ...userRow.displayName ? { displayName: userRow.displayName } : void 0
   });
 }
 async function resolveViewerUserFromSql(db, email) {
@@ -1457,7 +1457,7 @@ async function readActorIdentityFromSql(db, actor) {
   if (!row) return void 0;
   return {
     identity: identityFromRow(row.identity),
-    ...row.user ? { user: await readUserById(db, row.user) } : {}
+    ...row.user ? { user: await readUserById(db, row.user) } : void 0
   };
 }
 async function readActorIdentity(actor) {
@@ -2267,7 +2267,7 @@ function invocationPluginContext(plugin, context, turnId) {
         plugin,
         turnId
       })
-    } : {},
+    } : void 0,
     model: createPluginModel(plugin.manifest.name, plugin.model),
     source: context.source,
     text: context.userText ?? "",
@@ -2567,8 +2567,8 @@ function getPluginTools(context, sandbox = createSandboxCapability(context.works
       channelCapabilities: resolveChannelCapabilities(
         slackToolContext.sourceChannelId
       ),
-      ...dashboardConversationUrl ? { conversationLink: { url: dashboardConversationUrl } } : {},
-      ...credentialSubject ? { credentialSubject } : {}
+      ...dashboardConversationUrl ? { conversationLink: { url: dashboardConversationUrl } } : void 0,
+      ...credentialSubject ? { credentialSubject } : void 0
     } : void 0;
     const annotations = context.conversationId ? createPluginAnnotations({
       conversationId: context.conversationId,
@@ -2619,12 +2619,12 @@ function getPluginTools(context, sandbox = createSandboxCapability(context.works
     const resolveActor = context.resolveActorIdentity ?? (async () => void 0);
     const common = {
       ...basePluginContext(plugin),
-      ...annotations ? { annotations } : {},
+      ...annotations ? { annotations } : void 0,
       conversationId: context.conversationId,
       userText: context.userText,
       embedder: createPluginEmbedder(pluginName),
       egress: context.egress,
-      ...mcp ? { mcp } : {},
+      ...mcp ? { mcp } : void 0,
       model: createPluginModel(pluginName, plugin.model),
       resourceEvents,
       sandbox,
@@ -3213,7 +3213,7 @@ function createSandboxCapability(workspace, ownerSignal) {
       const signal = preparationSignal(input.signal, ownerSignal);
       const result = await runNonInteractiveCommand(workspace, {
         ...input,
-        ...signal ? { signal } : {}
+        ...signal ? { signal } : void 0
       });
       return {
         exitCode: result.exitCode,
@@ -3226,7 +3226,7 @@ function createSandboxCapability(workspace, ownerSignal) {
         {
           path: input.path,
           content: input.content,
-          ...input.mode !== void 0 ? { mode: input.mode } : {}
+          ...input.mode !== void 0 ? { mode: input.mode } : void 0
         }
       ]);
     }
@@ -3252,8 +3252,8 @@ function createPluginHookRunner(input = {}) {
         try {
           await hook({
             ...basePluginContext(plugin),
-            ...tool.conversationId ? { conversationId: tool.conversationId } : {},
-            ...annotations ? { annotations } : {},
+            ...tool.conversationId ? { conversationId: tool.conversationId } : void 0,
+            ...annotations ? { annotations } : void 0,
             result: tool.structuredContent !== void 0 ? { structuredContent: tool.structuredContent } : {},
             tool: {
               arguments: tool.arguments,

package/dist/chunk-DKIJ2RP5.js

@@ -0,0 +1,68 @@
+import {
+  conversationQueueMessageSchema
+} from "./chunk-JAL3CH4G.js";
+import {
+  QUEUE_SIGNATURE_MAX_AGE_MS,
+  createVercelQueueClient,
+  signQueueMessage,
+  verifyQueueMessage
+} from "./chunk-7H2VZTWN.js";
+
+// src/chat/task-execution/queue-signing.ts
+var conversationQueueSign = {
+  context: "junior.conversation_work_queue.v2",
+  schema: conversationQueueMessageSchema,
+  separator: ":",
+  signatureVersion: "v2",
+  parts: (message) => [message.conversationId]
+};
+var CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS = QUEUE_SIGNATURE_MAX_AGE_MS;
+function signConversationQueueMessage(message, nowMs = Date.now()) {
+  return signQueueMessage(conversationQueueSign, message, nowMs);
+}
+function verifyConversationQueueMessage(value, nowMs = Date.now()) {
+  return verifyQueueMessage(conversationQueueSign, value, nowMs);
+}
+
+// src/chat/task-execution/vercel-queue.ts
+var DEFAULT_CONVERSATION_WORK_QUEUE_TOPIC = "junior_conversation_work";
+var CONVERSATION_WORK_QUEUE_RETENTION_SECONDS = CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS / 1e3;
+var defaultQueue;
+function resolveConversationWorkQueueTopic(options = {}) {
+  const topic = options.topic?.trim();
+  return topic || process.env.JUNIOR_CONVERSATION_WORK_QUEUE_TOPIC?.trim() || DEFAULT_CONVERSATION_WORK_QUEUE_TOPIC;
+}
+function toDelaySeconds(options) {
+  if (!options?.delayMs || options.delayMs <= 0) {
+    return void 0;
+  }
+  return Math.ceil(options.delayMs / 1e3);
+}
+function createVercelConversationWorkQueue(options = {}) {
+  const topic = resolveConversationWorkQueueTopic(options);
+  const client = options.client ?? createVercelQueueClient();
+  return {
+    async send(message, sendOptions) {
+      const result = await client.send(
+        topic,
+        signConversationQueueMessage(message),
+        {
+          idempotencyKey: sendOptions?.idempotencyKey,
+          delaySeconds: toDelaySeconds(sendOptions),
+          retentionSeconds: options.retentionSeconds ?? CONVERSATION_WORK_QUEUE_RETENTION_SECONDS
+        }
+      );
+      return result.messageId ? { messageId: result.messageId } : {};
+    }
+  };
+}
+function getVercelConversationWorkQueue() {
+  defaultQueue ??= createVercelConversationWorkQueue();
+  return defaultQueue;
+}
+
+export {
+  verifyConversationQueueMessage,
+  resolveConversationWorkQueueTopic,
+  getVercelConversationWorkQueue
+};

package/dist/{chunk-YFNAMRGE.js → chunk-DRHEGXTZ.js}

@@ -1,6 +1,6 @@
 import {
   createPluginCatalogRuntime
-} from "./chunk-SLGGOASN.js";
+} from "./chunk-2YIRH4E3.js";
 
 // src/chat/plugins/catalog-runtime.ts
 var pluginCatalogRuntime = createPluginCatalogRuntime();

package/dist/{chunk-OOUNJNMR.js → chunk-DWPN6SCH.js}

@@ -4,7 +4,7 @@ import {
   isFile,
   isValidPackageName,
   resolvePackageLocation
-} from "./chunk-H4HBKISO.js";
+} from "./chunk-TXKUKMVO.js";
 
 // src/chat/plugins/package-discovery.ts
 import path from "path";

package/dist/chunk-EWHP2IRG.js

@@ -0,0 +1,209 @@
+import {
+  coerceThreadConversationState,
+  getPersistedThreadState,
+  persistThreadStateById
+} from "./chunk-5TUR4M3M.js";
+import {
+  buildDeterministicTurnId,
+  clearPendingAuth,
+  markTurnClosed,
+  markTurnCompleted
+} from "./chunk-GUKXEPMX.js";
+import {
+  hydrateConversationMessages,
+  markConversationMessage
+} from "./chunk-GPXAHUQH.js";
+import {
+  ProviderError,
+  findProviderError,
+  getProviderErrorAttributes,
+  getProviderErrorUserMessage
+} from "./chunk-I6IFTAPF.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-N7TMSOZH.js";
+import {
+  buildTurnFailureResponse
+} from "./chunk-RAZG3YHC.js";
+
+// src/chat/runtime/delivered-turn-state.ts
+function buildDeliveredTurnStatePatch(args) {
+  const conversation = structuredClone(args.conversation);
+  clearPendingAuth(conversation, args.sessionId);
+  markConversationMessage(conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  markTurnCompleted({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId
+  });
+  return {
+    conversation,
+    sandboxRef: args.reply.sandboxRef
+  };
+}
+
+// src/chat/interruption-marker.ts
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+function getInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+
+// src/chat/services/turn-failure-response.ts
+function requireTurnFailureEventId(eventId, eventName) {
+  if (!eventId) {
+    throw new Error(`Sentry did not return an event ID for ${eventName}`);
+  }
+  return eventId;
+}
+function getExecutionFailureReason(reply) {
+  const errorMessage = reply.diagnostics.errorMessage?.trim();
+  if (errorMessage) {
+    return errorMessage;
+  }
+  if (reply.diagnostics.toolErrorCount > 0) {
+    return `${reply.diagnostics.toolErrorCount} tool result error(s)`;
+  }
+  if (reply.diagnostics.assistantMessageCount > 0) {
+    return "assistant returned no text";
+  }
+  return "empty assistant turn";
+}
+function getFailureCapture(reply) {
+  if (reply.diagnostics.outcome === "provider_error") {
+    const providerError = findProviderError(reply.diagnostics.providerError);
+    return {
+      eventName: "agent.turn.provider_error",
+      error: reply.diagnostics.providerError ?? new Error(
+        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
+      ),
+      attributes: providerError ? getProviderErrorAttributes(providerError) : {},
+      body: "Agent turn failed with provider error"
+    };
+  }
+  const failureReason = getExecutionFailureReason(reply);
+  return {
+    eventName: "agent.turn.execution.failed",
+    error: new Error(`Agent turn execution failure: ${failureReason}`),
+    attributes: {
+      "app.ai.execution_failure_reason": failureReason
+    },
+    body: "Agent turn completed with execution failure"
+  };
+}
+function getAgentTurnDiagnosticsAttributes(reply) {
+  return {
+    "app.ai.outcome": reply.diagnostics.outcome,
+    "app.ai.assistant_messages": reply.diagnostics.assistantMessageCount,
+    "app.ai.tool_results": reply.diagnostics.toolResultCount,
+    "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
+    "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
+    "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
+    ...reply.diagnostics.reasoningLevel ? {
+      "gen_ai.request.reasoning.level": reply.diagnostics.reasoningLevel
+    } : void 0,
+    ...reply.diagnostics.stopReason ? {
+      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
+    } : void 0,
+    ...reply.diagnostics.errorMessage && reply.diagnostics.outcome !== "provider_error" ? { "exception.message": reply.diagnostics.errorMessage } : void 0
+  };
+}
+function finalizeFailedTurnReplyWithEvent(args) {
+  if (args.reply.diagnostics.outcome === "success") {
+    return { reply: args.reply };
+  }
+  const capture = getFailureCapture(args.reply);
+  const eventId = requireTurnFailureEventId(
+    args.logException(capture.error, capture.eventName, {
+      ...getAgentTurnDiagnosticsAttributes(args.reply),
+      ...args.attributes,
+      ...capture.attributes
+    }),
+    capture.eventName
+  );
+  const providerPartialText = args.reply.diagnostics.outcome === "provider_error" && args.reply.diagnostics.assistantMessageCount > 0 ? args.reply.text.trim() : "";
+  const providerUserMessage = args.reply.diagnostics.providerError instanceof ProviderError ? getProviderErrorUserMessage(args.reply.diagnostics.providerError) : "";
+  const failureText = providerUserMessage ? `${providerUserMessage} Reference: \`event_id=${eventId}\`.` : buildTurnFailureResponse(eventId);
+  return {
+    eventId,
+    reply: {
+      ...args.reply,
+      text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : failureText
+    }
+  };
+}
+
+// src/chat/runtime/turn-user-message.ts
+function getTurnUserMessage(conversation, sessionId) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    if (buildDeterministicTurnId(message.id) === sessionId) {
+      return message;
+    }
+  }
+  return void 0;
+}
+function getTurnUserMessageId(conversation, sessionId) {
+  return getTurnUserMessage(conversation, sessionId)?.id;
+}
+function getTurnUserSlackMessageTs(message) {
+  return parseSlackMessageTs(message?.meta?.slackTs);
+}
+function getTurnUserReplyAttachmentContext(message) {
+  const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
+  const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
+  const imagesHydrated = message?.meta?.imagesHydrated === true;
+  return {
+    ...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : void 0,
+    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : void 0
+  };
+}
+
+// src/chat/runtime/auth-pause-state.ts
+function completeAuthPauseTurn(args) {
+  markConversationMessage(
+    args.conversation,
+    getTurnUserMessageId(args.conversation, args.sessionId),
+    {
+      replied: true,
+      skippedReason: void 0
+    }
+  );
+  markTurnClosed({
+    conversation: args.conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId
+  });
+}
+async function persistAuthPauseTurnState(args) {
+  const currentState = await getPersistedThreadState(args.threadStateId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.threadStateId
+  });
+  completeAuthPauseTurn({
+    conversation,
+    sessionId: args.sessionId
+  });
+  await persistThreadStateById(args.threadStateId, { conversation });
+}
+
+export {
+  buildDeliveredTurnStatePatch,
+  getTurnUserMessage,
+  getTurnUserMessageId,
+  getTurnUserSlackMessageTs,
+  getTurnUserReplyAttachmentContext,
+  getInterruptionMarker,
+  requireTurnFailureEventId,
+  getAgentTurnDiagnosticsAttributes,
+  finalizeFailedTurnReplyWithEvent,
+  completeAuthPauseTurn,
+  persistAuthPauseTurnState
+};

package/dist/{chunk-R6U7N4FS.js → chunk-FGC3PHNH.js}

@@ -1,10 +1,10 @@
-import {
-  DEFAULT_SQL_STATEMENT_TIMEOUT_MS
-} from "./chunk-GENV6KF2.js";
 import {
   juniorDestinations,
   timestamptz
 } from "./chunk-VFUK3X5B.js";
+import {
+  DEFAULT_SQL_STATEMENT_TIMEOUT_MS
+} from "./chunk-I6IFTAPF.js";
 
 // src/db/neon.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-3TM3FYLQ.js → chunk-GA5NS74S.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-GENV6KF2.js";
+} from "./chunk-I6IFTAPF.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";