@sentry/junior 0.183.0 → 0.185.0

package/dist/{chunk-X52ESOBP.js → chunk-EJYP3NQ4.js}

@@ -1,13 +1,13 @@
 import {
   toOptionalTrimmed
-} from "./chunk-LMNMMESF.js";
+} from "./chunk-LRI5IRGY.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-E3OBGRHN.js";
+} from "./chunk-GJTIZQGJ.js";
 import {
   setSpanAttributes,
   setSpanStatus
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
@@ -591,7 +591,7 @@ function isAbortError(error) {
     if (!(candidate instanceof Error)) return false;
     if (candidate.name === "AbortError") return true;
     const message = candidate.message.toLowerCase();
-    return message === "api turn cancelled" || message === "api turn canceled" || message.startsWith("executeagentrun timed out after");
+    return message.startsWith("executeagentrun timed out after");
   });
 }
 function isSandboxApiTransientError(error) {

package/dist/{chunk-35PM4YY5.js → chunk-EWEH2PJW.js}

@@ -7,23 +7,23 @@ import {
 import {
   formatProviderLabel,
   startOAuthFlow
-} from "./chunk-QI5JW5AG.js";
+} from "./chunk-ZKKGFUWM.js";
 import {
   abandonReplacedPendingAuth,
   canReusePendingAuthLink
-} from "./chunk-56XONJPF.js";
+} from "./chunk-U4CTAVWN.js";
 import {
   recordAuthorizationRequested
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-WLKWN4CD.js";
 import {
   AGENT_INVOCATION_MAILBOX_STATUSES
-} from "./chunk-6UXDTPEN.js";
+} from "./chunk-LVK4WJKM.js";
 import {
   TURN_REASONING_LEVELS
-} from "./chunk-LMNMMESF.js";
+} from "./chunk-D4YV5TDV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-E3OBGRHN.js";
+} from "./chunk-GJTIZQGJ.js";
 import {
   credentialContextSchema
 } from "./chunk-CEMMLV5L.js";

package/dist/{chunk-W5JMPEBO.js → chunk-FFHXG2FX.js}

@@ -1,12 +1,12 @@
 import {
   coerceThreadConversationState,
   getPersistedThreadState
-} from "./chunk-PLZT45VC.js";
+} from "./chunk-Y5G23T2D.js";
 import {
   pluginTaskId,
   pluginTaskParamsSchema,
   sendVercelPluginTask
-} from "./chunk-V64JCZUV.js";
+} from "./chunk-4S47VHJR.js";
 import {
   getPiMessageRole,
   getTurnRecord,
@@ -16,7 +16,7 @@ import {
   isToolResultMessage,
   normalizeToolNameFromResult,
   stripRuntimeTurnContext
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-WLKWN4CD.js";
 import {
   createPluginConversationEvents,
   createPluginEmbedder,
@@ -25,22 +25,24 @@ import {
   createPluginState,
   getPlugins,
   readActorIdentity
-} from "./chunk-AHMWPFIW.js";
+} from "./chunk-VH4IU3UC.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
 import {
   getConversationStore,
-  getDb,
-  sameActorIdentity
-} from "./chunk-AX3UDIMA.js";
+  getDb
+} from "./chunk-ABAX75GG.js";
 import {
   juniorConversations,
   juniorTaskExecutions
-} from "./chunk-6UXDTPEN.js";
+} from "./chunk-LVK4WJKM.js";
 import {
   getStateAdapter
-} from "./chunk-G2B2XZQW.js";
+} from "./chunk-PNYJOEVV.js";
+import {
+  sameActorIdentity
+} from "./chunk-GFBR4S3Q.js";
 import {
   credentialSubjectSchema
 } from "./chunk-CEMMLV5L.js";
@@ -49,14 +51,14 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   logWarn
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/plugins/task-runner.ts
 import { pluginRunContextSchema } from "@sentry/junior-plugin-api";
 
 // src/chat/services/turn-session-routing.ts
 async function resolveTurnSessionRouting(args) {
-  const conversationStore = args.conversationStore ?? (await import("./db-K2VMNLHQ.js")).getConversationStore();
+  const conversationStore = args.conversationStore ?? (await import("./db-TRJ77FAU.js")).getConversationStore();
   const conversation = await conversationStore.get({
     conversationId: args.conversationId
   });

package/dist/{chunk-FJMTMGBC.js → chunk-FTVMXDNN.js}

@@ -1,7 +1,7 @@
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig
-} from "./chunk-LMNMMESF.js";
+} from "./chunk-LRI5IRGY.js";
 
 // src/chat/runtime/request-deadline.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/chunk-GFBR4S3Q.js

@@ -0,0 +1,406 @@
+import {
+  TURN_REASONING_LEVELS,
+  modelProfileSchema
+} from "./chunk-D4YV5TDV.js";
+
+// src/chat/conversations/provenance.ts
+import { actorSchema } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var conversationMessageAuthoritySchema = z.union([
+  z.literal("instruction"),
+  z.literal("context")
+]);
+var conversationMessageProvenanceSchema = z.object({
+  authority: conversationMessageAuthoritySchema,
+  actor: actorSchema.optional()
+}).strict();
+function instructionProvenanceFor(actor) {
+  return actor ? { authority: "instruction", actor } : { authority: "instruction" };
+}
+var contextProvenance = {
+  authority: "context"
+};
+function actorIdentityKey(actor) {
+  if (actor.platform === "system") {
+    return `system ${actor.name}`;
+  }
+  return actor.platform === "slack" ? `slack\0${actor.teamId}\0${actor.userId}` : `${actor.platform}\0${actor.userId}`;
+}
+function sameActorIdentity(left, right) {
+  return Boolean(
+    left && right && actorIdentityKey(left) === actorIdentityKey(right)
+  );
+}
+function instructionActors(provenance) {
+  const seen = /* @__PURE__ */ new Set();
+  const actors = [];
+  for (const entry of provenance) {
+    if (entry.authority !== "instruction" || !entry.actor) {
+      continue;
+    }
+    const identity = actorIdentityKey(entry.actor);
+    if (seen.has(identity)) {
+      continue;
+    }
+    seen.add(identity);
+    actors.push(entry.actor);
+  }
+  return actors;
+}
+
+// src/chat/conversations/history.ts
+import { z as z2 } from "zod";
+var userMessageEventDataSchema = z2.object({
+  type: z2.literal("user_message"),
+  role: z2.never().optional(),
+  provenance: conversationMessageProvenanceSchema
+}).passthrough();
+var assistantMessageEventDataSchema = z2.object({
+  type: z2.literal("assistant_message"),
+  role: z2.never().optional()
+}).passthrough();
+var toolResultEventDataSchema = z2.object({
+  type: z2.literal("tool_result"),
+  role: z2.never().optional()
+}).passthrough();
+var agentHistoryItemSchema = z2.discriminatedUnion("type", [
+  userMessageEventDataSchema,
+  assistantMessageEventDataSchema,
+  toolResultEventDataSchema
+]);
+var nativeReplacementHistoryItemSchema = z2.object({
+  item: agentHistoryItemSchema,
+  // Preserve the copied item's position when a turn resumes. Synthetic
+  // summary and handoff items have no source event.
+  sourceEventSeq: z2.number().int().nonnegative().optional()
+}).strict();
+var replacementHistorySchema = z2.array(nativeReplacementHistoryItemSchema);
+var compactionDetailsSchema = z2.object({
+  reason: z2.literal("capacity"),
+  estimatedInputTokens: z2.number().int().nonnegative(),
+  replacementInputTokens: z2.number().int().nonnegative().optional(),
+  triggerTokens: z2.number().int().nonnegative(),
+  inputLimitTokens: z2.number().int().positive(),
+  inputMessageCount: z2.number().int().nonnegative(),
+  retainedMessageCount: z2.number().int().nonnegative(),
+  summaryChars: z2.number().int().nonnegative()
+}).strict();
+var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("handoff"),
+    modelProfile: modelProfileSchema,
+    modelId: z2.string().min(1),
+    reasoningLevel: z2.string().min(1).optional(),
+    triggeringToolCallId: z2.string().min(1).optional(),
+    summary: z2.string().min(1).optional(),
+    replacementHistory: replacementHistorySchema
+  }).strict(),
+  z2.object({
+    type: z2.literal("compaction"),
+    modelProfile: modelProfileSchema,
+    modelId: z2.string().min(1),
+    details: compactionDetailsSchema.optional(),
+    summary: z2.string().min(1).optional(),
+    replacementHistory: replacementHistorySchema
+  }).strict()
+]);
+var historyReplacementSchema = z2.object({
+  data: historyReplacementEventDataSchema,
+  createdAtMs: z2.number().finite()
+}).strict();
+var mcpProviderConnectedEventDataSchema = z2.object({
+  type: z2.literal("mcp_provider_connected"),
+  provider: z2.string().min(1),
+  credentialSubjectId: z2.string().min(1)
+}).strict();
+var unownedMcpProviderConnectedEventDataSchema = z2.object({
+  type: z2.literal("mcp_provider_connected_unowned"),
+  provider: z2.string().min(1)
+}).strict();
+var authorizationKindSchema = z2.union([
+  z2.literal("plugin"),
+  z2.literal("mcp")
+]);
+var authorizationRequestedEventDataSchema = z2.object({
+  type: z2.literal("authorization_requested"),
+  kind: authorizationKindSchema,
+  provider: z2.string().min(1),
+  actorId: z2.string().min(1),
+  authorizationId: z2.string().min(1),
+  delivery: z2.union([
+    z2.literal("private_link_sent"),
+    z2.literal("private_link_reused")
+  ])
+}).strict();
+var authorizationCompletedEventDataSchema = z2.object({
+  type: z2.literal("authorization_completed"),
+  kind: authorizationKindSchema,
+  provider: z2.string().min(1),
+  actorId: z2.string().min(1),
+  authorizationId: z2.string().min(1)
+}).strict();
+var toolExecutionStartedEventDataSchema = z2.object({
+  type: z2.literal("tool_execution_started"),
+  toolCallId: z2.string().min(1),
+  toolName: z2.string().min(1)
+}).strict();
+var guardianActionReviewedEventDataSchema = z2.object({
+  type: z2.literal("guardian_action_reviewed"),
+  turnId: z2.string().min(1),
+  toolCallId: z2.string().min(1),
+  toolName: z2.string().min(1),
+  costUsd: z2.number().finite().nonnegative().optional(),
+  decision: z2.enum(["allow", "ask", "deny"]),
+  riskLevel: z2.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z2.enum(["high", "medium", "low", "unknown"])
+}).strict();
+var conversationMessageRoleSchema = z2.union([
+  z2.literal("user"),
+  z2.literal("assistant"),
+  z2.literal("system")
+]);
+var messageEventDataSchema = z2.object({
+  type: z2.literal("message"),
+  messageId: z2.string().min(1),
+  role: conversationMessageRoleSchema,
+  text: z2.string(),
+  authorIdentityId: z2.string().min(1).optional(),
+  meta: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var messageUpdatedEventDataSchema = messageEventDataSchema.extend({
+  type: z2.literal("message_updated")
+});
+var messageHandledEventDataSchema = z2.object({
+  type: z2.literal("message_handled"),
+  messageId: z2.string().min(1)
+}).strict();
+var messagesSummarizedEventDataSchema = z2.object({
+  type: z2.literal("messages_summarized"),
+  historyFromSeq: z2.number().int().nonnegative(),
+  compactions: z2.array(
+    z2.object({
+      coveredMessageCount: z2.number().int().nonnegative(),
+      createdAtMs: z2.number(),
+      id: z2.string().min(1),
+      summary: z2.string()
+    }).strict()
+  )
+}).strict();
+var conversationTurnSurfaceSchema = z2.enum([
+  "slack",
+  "api",
+  "scheduler",
+  "internal"
+]);
+var conversationTurnFailureCodeSchema = z2.enum([
+  "agent_run_failed",
+  "delivery_failed",
+  "model_execution_failed",
+  "persistence_failed"
+]);
+var conversationTurnFailureReasonSchema = z2.enum([
+  "auth",
+  "permission",
+  "rate_limit",
+  "capacity",
+  "timeout",
+  "network",
+  "server",
+  "invalid_request",
+  "invalid_response",
+  "quota",
+  "content_policy",
+  "unknown",
+  "empty_output",
+  "tool_errors",
+  "suppressed_output"
+]);
+var turnStartedEventDataSchema = z2.object({
+  type: z2.literal("turn_started"),
+  turnId: z2.string().min(1),
+  inputMessageIds: z2.array(z2.string().min(1)).min(1),
+  surface: conversationTurnSurfaceSchema
+}).strict().refine(
+  (data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length,
+  "turn input message ids must be unique"
+);
+var turnRoutedEventDataSchema = z2.object({
+  type: z2.literal("turn_routed"),
+  turnId: z2.string().min(1),
+  modelProfile: modelProfileSchema,
+  modelId: z2.string().min(1),
+  costUsd: z2.number().finite().nonnegative().optional(),
+  reasoningLevel: z2.enum(TURN_REASONING_LEVELS),
+  confidence: z2.number().min(0).max(1).optional(),
+  source: z2.enum(["configured", "inherited", "router"])
+}).strict();
+var turnContextEventDataSchema = z2.object({
+  type: z2.literal("turn_context"),
+  turnId: z2.string().min(1),
+  pluginName: z2.string().min(1),
+  kind: z2.string().min(1).max(64),
+  version: z2.number().int().positive(),
+  content: z2.record(z2.string(), z2.unknown())
+}).strict();
+var structuredConversationEventDataSchema = z2.object({
+  type: z2.literal("structured_event"),
+  namespace: z2.string().regex(/^[a-z][a-z0-9-]*$/),
+  name: z2.string().regex(/^[a-z][a-z0-9_]*$/),
+  version: z2.number().int().positive(),
+  turnId: z2.string().min(1).optional(),
+  content: z2.record(z2.string(), z2.unknown())
+}).strict();
+var deliveredAttachmentSchema = z2.object({
+  id: z2.string().min(1),
+  filename: z2.string().min(1),
+  contentType: z2.string().min(1),
+  bytes: z2.number().int().nonnegative()
+}).strict();
+var attachmentsDeliveredEventDataSchema = z2.object({
+  type: z2.literal("attachments_delivered"),
+  attachments: z2.array(deliveredAttachmentSchema).min(1),
+  toolCallId: z2.string().min(1).optional(),
+  turnId: z2.string().min(1).optional()
+}).strict();
+var turnCompletedEventDataSchema = z2.object({
+  type: z2.literal("turn_completed"),
+  turnId: z2.string().min(1),
+  outcome: z2.enum(["success", "no_reply", "cancelled"])
+}).strict();
+var turnFailedEventDataSchema = z2.object({
+  type: z2.literal("turn_failed"),
+  turnId: z2.string().min(1),
+  failureCode: conversationTurnFailureCodeSchema,
+  failureReason: conversationTurnFailureReasonSchema.optional(),
+  eventId: z2.string().regex(/^[a-f0-9]{32}$/i).optional()
+}).strict();
+var subagentStartedEventDataSchema = z2.object({
+  type: z2.literal("subagent_started"),
+  subagentInvocationId: z2.string().min(1),
+  subagentKind: z2.string().min(1),
+  modelId: z2.string().min(1).optional(),
+  parentToolCallId: z2.string().min(1).optional(),
+  reasoningLevel: z2.string().min(1).optional(),
+  childConversationId: z2.string().min(1)
+}).strict();
+var subagentEndedEventDataSchema = z2.object({
+  type: z2.literal("subagent_ended"),
+  subagentInvocationId: z2.string().min(1),
+  outcome: z2.union([
+    z2.literal("success"),
+    z2.literal("error"),
+    z2.literal("aborted")
+  ]),
+  errorCode: z2.string().min(1).optional()
+}).strict();
+var appendableConversationEventDataSchema = z2.union([
+  messageEventDataSchema,
+  messageUpdatedEventDataSchema,
+  agentHistoryItemSchema,
+  mcpProviderConnectedEventDataSchema,
+  authorizationRequestedEventDataSchema,
+  authorizationCompletedEventDataSchema,
+  toolExecutionStartedEventDataSchema,
+  guardianActionReviewedEventDataSchema,
+  messageHandledEventDataSchema,
+  messagesSummarizedEventDataSchema,
+  turnStartedEventDataSchema,
+  turnContextEventDataSchema,
+  structuredConversationEventDataSchema,
+  attachmentsDeliveredEventDataSchema,
+  turnRoutedEventDataSchema,
+  turnCompletedEventDataSchema,
+  turnFailedEventDataSchema,
+  subagentStartedEventDataSchema,
+  subagentEndedEventDataSchema
+]);
+var conversationEventDataSchema = z2.union([
+  appendableConversationEventDataSchema,
+  historyReplacementEventDataSchema,
+  unownedMcpProviderConnectedEventDataSchema
+]);
+var KNOWN_CONVERSATION_EVENT_TYPES = [
+  "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",
+  "attachments_delivered",
+  "turn_routed",
+  "turn_completed",
+  "turn_failed",
+  "subagent_started",
+  "subagent_ended",
+  "handoff",
+  "compaction"
+];
+var knownConversationEventTypeSchema = z2.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var unknownConversationEventDataSchema = z2.object({
+  type: z2.literal("unknown"),
+  originalType: z2.string().min(1),
+  payload: z2.unknown()
+}).strict();
+var conversationEventEnvelopeSchema = z2.object({
+  schemaVersion: z2.number().int().nonnegative(),
+  seq: z2.number().int().nonnegative(),
+  historyVersion: z2.number().int().nonnegative(),
+  idempotencyKey: z2.string().min(1).optional(),
+  createdAtMs: z2.number().finite()
+}).strict();
+var conversationEventSchema = z2.union([
+  conversationEventEnvelopeSchema.extend({
+    schemaVersion: z2.literal(1),
+    data: conversationEventDataSchema
+  }),
+  conversationEventEnvelopeSchema.extend({
+    data: unknownConversationEventDataSchema
+  })
+]);
+var storedConversationEventSchema = conversationEventEnvelopeSchema.extend({
+  type: z2.string().min(1),
+  payload: z2.unknown()
+});
+function decodeStoredConversationEvent(value) {
+  const stored = storedConversationEventSchema.parse(value);
+  const { type, payload, ...envelope } = stored;
+  const knownType = knownConversationEventTypeSchema.safeParse(type).success;
+  if (stored.schemaVersion === 1 && knownType) {
+    const data = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? { ...payload, type } : { type };
+    return conversationEventSchema.parse({ ...envelope, data });
+  }
+  return conversationEventSchema.parse({
+    ...envelope,
+    data: { type: "unknown", originalType: type, payload }
+  });
+}
+var newConversationEventSchema = z2.object({
+  data: appendableConversationEventDataSchema,
+  idempotencyKey: z2.string().min(1).optional(),
+  createdAtMs: z2.number().finite()
+}).strict();
+
+export {
+  instructionProvenanceFor,
+  contextProvenance,
+  sameActorIdentity,
+  instructionActors,
+  agentHistoryItemSchema,
+  historyReplacementSchema,
+  conversationTurnFailureCodeSchema,
+  conversationTurnFailureReasonSchema,
+  conversationEventDataSchema,
+  KNOWN_CONVERSATION_EVENT_TYPES,
+  decodeStoredConversationEvent,
+  newConversationEventSchema
+};

package/dist/{chunk-E3OBGRHN.js → chunk-GJTIZQGJ.js}

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

package/dist/{chunk-IO6KFXYE.js → chunk-HJPC32TQ.js}

@@ -1,11 +1,15 @@
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-W7GCLNIV.js";
 import {
   ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+} from "./chunk-6Q7YZLCL.js";
 import {
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-PLZT45VC.js";
+} from "./chunk-Y5G23T2D.js";
 import {
   AgentInvocationBusyError,
   AgentInvocationLimitError,
@@ -14,78 +18,36 @@ import {
   agentBindingSchema,
   agentInvocationSchema,
   createAgentInvocationSchema
-} from "./chunk-35PM4YY5.js";
+} from "./chunk-EWEH2PJW.js";
 import {
   appendAndEnqueueInboundMessage
-} from "./chunk-HUK5XIZL.js";
+} from "./chunk-D63IUQQE.js";
 import {
   TurnInputCommitLostError,
   getAssistantReplyText,
   getConversationTurnBoundaryError,
   isTurnInputCommitLostError
-} from "./chunk-56XONJPF.js";
+} from "./chunk-U4CTAVWN.js";
 import {
   failTurnRecord,
   getTerminalAssistantMessages,
   getTurnRecord,
   openConversationProjection,
   saveTurnCheckpoint
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-WLKWN4CD.js";
 import {
   getConversationEventStore,
   getConversationStore,
   getSqlExecutor
-} from "./chunk-AX3UDIMA.js";
+} from "./chunk-ABAX75GG.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations
-} from "./chunk-6UXDTPEN.js";
+} from "./chunk-LVK4WJKM.js";
 
 // src/chat/agent-invocations/work.ts
 import { z } from "zod";
 
-// src/chat/runtime/turn-execution.ts
-var AgentRunError = class extends Error {
-  constructor(cause) {
-    super(cause instanceof Error ? cause.message : "Agent Run failed", {
-      cause
-    });
-    this.name = "AgentRunError";
-  }
-};
-async function executeTurn(agentRunner, run, saveResult) {
-  let outcome;
-  try {
-    outcome = await agentRunner.run(run);
-  } catch (error) {
-    throw new AgentRunError(error);
-  }
-  if (outcome.status !== "completed") {
-    return outcome;
-  }
-  const saved = await saveResult(outcome.result);
-  const lifecycle = new ConversationTurnLifecycleService(
-    getConversationEventStore()
-  );
-  const common = {
-    conversationId: run.conversationId,
-    createdAtMs: saved.finishedAtMs ?? Date.now(),
-    turnId: run.turnId
-  };
-  if (saved.outcome === "failed") {
-    await lifecycle.fail({
-      ...common,
-      failureCode: saved.failureCode
-    });
-  } else {
-    await lifecycle.complete({
-      ...common,
-      outcome: saved.outcome
-    });
-  }
-  return { status: "completed" };
-}
-
 // src/chat/agent-invocations/store.ts
 import { createHash } from "crypto";
 import { and, asc, count, eq, inArray } from "drizzle-orm";