@sentry/junior 0.184.0 → 0.186.0

package/dist/{chunk-IZDYYYGP.js → chunk-43LODHJM.js}

@@ -8,15 +8,19 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-BCHYQS4B.js";
+} from "./chunk-VXL2LBPK.js";
+import {
+  conversationEventDataSchema,
+  decodeStoredConversationEvent,
+  historyReplacementSchema,
+  newConversationEventSchema
+} from "./chunk-GFBR4S3Q.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
-  TURN_REASONING_LEVELS,
-  getChatConfig,
-  modelProfileSchema
-} from "./chunk-6UDPINOX.js";
+  getChatConfig
+} from "./chunk-AD64YMEC.js";
 import {
   parseActorUserId,
   parseSlackChannelReferenceId,
@@ -24,7 +28,7 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -773,6 +777,9 @@ var SqlStore = class {
     await this.withConversationMutation(args.conversationId, async () => {
       const existingRow = await this.readConversationRow(args.conversationId);
       const existing = existingRow ? conversationFromRow(existingRow) : void 0;
+      if (!existing && !args.destination) {
+        return;
+      }
       const incomingExecutionAt = args.execution.updatedAtMs ?? args.updatedAtMs;
       const existingExecutionAt = existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0;
       const incomingIsFresh = incomingExecutionAt >= existingExecutionAt;
@@ -786,6 +793,7 @@ var SqlStore = class {
           createdAtMs: args.createdAtMs,
           lastActivityAtMs: args.lastActivityAtMs,
           updatedAtMs: args.updatedAtMs,
+          ...existing?.lineage ? { lineage: existing.lineage } : void 0,
           ...args.channelName ? { channelName: args.channelName } : void 0,
           ...args.destination ? { destination: args.destination } : void 0,
           ...args.actor ? { actor: args.actor } : void 0,
@@ -913,6 +921,16 @@ var SqlStore = class {
   /** Upsert the conversation row while preserving previously discovered nullable metadata fields. */
   async upsertConversation(args) {
     const { conversation } = args;
+    if (!conversation.lineage && !conversation.destination) {
+      const existing = await this.get({
+        conversationId: conversation.conversationId
+      });
+      if (!existing) {
+        throw new Error(
+          `Conversation ${conversation.conversationId} requires a destination at create`
+        );
+      }
+    }
     const incomingExecutionVersion = sql3`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
     const currentExecutionVersion = sql3`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
     const incomingExecutionIsFresh = sql3`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
@@ -1059,377 +1077,6 @@ import {
   sql as sql6
 } from "drizzle-orm";
 
-// src/chat/conversations/history.ts
-import { z as z3 } from "zod";
-
-// src/chat/conversations/provenance.ts
-import { actorSchema } from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-var conversationMessageAuthoritySchema = z2.union([
-  z2.literal("instruction"),
-  z2.literal("context")
-]);
-var conversationMessageProvenanceSchema = z2.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
-var userMessageEventDataSchema = z3.object({
-  type: z3.literal("user_message"),
-  role: z3.never().optional(),
-  provenance: conversationMessageProvenanceSchema
-}).passthrough();
-var assistantMessageEventDataSchema = z3.object({
-  type: z3.literal("assistant_message"),
-  role: z3.never().optional()
-}).passthrough();
-var toolResultEventDataSchema = z3.object({
-  type: z3.literal("tool_result"),
-  role: z3.never().optional()
-}).passthrough();
-var agentHistoryItemSchema = z3.discriminatedUnion("type", [
-  userMessageEventDataSchema,
-  assistantMessageEventDataSchema,
-  toolResultEventDataSchema
-]);
-var nativeReplacementHistoryItemSchema = z3.object({
-  item: agentHistoryItemSchema,
-  // Preserve the copied item's position when a turn resumes. Synthetic
-  // summary and handoff items have no source event.
-  sourceEventSeq: z3.number().int().nonnegative().optional()
-}).strict();
-var replacementHistorySchema = z3.array(nativeReplacementHistoryItemSchema);
-var compactionDetailsSchema = z3.object({
-  reason: z3.literal("capacity"),
-  estimatedInputTokens: z3.number().int().nonnegative(),
-  replacementInputTokens: z3.number().int().nonnegative().optional(),
-  triggerTokens: z3.number().int().nonnegative(),
-  inputLimitTokens: z3.number().int().positive(),
-  inputMessageCount: z3.number().int().nonnegative(),
-  retainedMessageCount: z3.number().int().nonnegative(),
-  summaryChars: z3.number().int().nonnegative()
-}).strict();
-var historyReplacementEventDataSchema = z3.discriminatedUnion("type", [
-  z3.object({
-    type: z3.literal("handoff"),
-    modelProfile: modelProfileSchema,
-    modelId: z3.string().min(1),
-    reasoningLevel: z3.string().min(1).optional(),
-    triggeringToolCallId: z3.string().min(1).optional(),
-    summary: z3.string().min(1).optional(),
-    replacementHistory: replacementHistorySchema
-  }).strict(),
-  z3.object({
-    type: z3.literal("compaction"),
-    modelProfile: modelProfileSchema,
-    modelId: z3.string().min(1),
-    details: compactionDetailsSchema.optional(),
-    summary: z3.string().min(1).optional(),
-    replacementHistory: replacementHistorySchema
-  }).strict()
-]);
-var historyReplacementSchema = z3.object({
-  data: historyReplacementEventDataSchema,
-  createdAtMs: z3.number().finite()
-}).strict();
-var mcpProviderConnectedEventDataSchema = z3.object({
-  type: z3.literal("mcp_provider_connected"),
-  provider: z3.string().min(1),
-  credentialSubjectId: z3.string().min(1)
-}).strict();
-var unownedMcpProviderConnectedEventDataSchema = z3.object({
-  type: z3.literal("mcp_provider_connected_unowned"),
-  provider: z3.string().min(1)
-}).strict();
-var authorizationKindSchema = z3.union([
-  z3.literal("plugin"),
-  z3.literal("mcp")
-]);
-var authorizationRequestedEventDataSchema = z3.object({
-  type: z3.literal("authorization_requested"),
-  kind: authorizationKindSchema,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1),
-  delivery: z3.union([
-    z3.literal("private_link_sent"),
-    z3.literal("private_link_reused")
-  ])
-}).strict();
-var authorizationCompletedEventDataSchema = z3.object({
-  type: z3.literal("authorization_completed"),
-  kind: authorizationKindSchema,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1)
-}).strict();
-var toolExecutionStartedEventDataSchema = z3.object({
-  type: z3.literal("tool_execution_started"),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1)
-}).strict();
-var guardianActionReviewedEventDataSchema = z3.object({
-  type: z3.literal("guardian_action_reviewed"),
-  turnId: z3.string().min(1),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1),
-  costUsd: z3.number().finite().nonnegative().optional(),
-  decision: z3.enum(["allow", "ask", "deny"]),
-  riskLevel: z3.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z3.enum(["high", "medium", "low", "unknown"])
-}).strict();
-var conversationMessageRoleSchema = z3.union([
-  z3.literal("user"),
-  z3.literal("assistant"),
-  z3.literal("system")
-]);
-var messageEventDataSchema = z3.object({
-  type: z3.literal("message"),
-  messageId: z3.string().min(1),
-  role: conversationMessageRoleSchema,
-  text: z3.string(),
-  authorIdentityId: z3.string().min(1).optional(),
-  meta: z3.record(z3.string(), z3.unknown()).optional()
-}).strict();
-var messageUpdatedEventDataSchema = messageEventDataSchema.extend({
-  type: z3.literal("message_updated")
-});
-var messageHandledEventDataSchema = z3.object({
-  type: z3.literal("message_handled"),
-  messageId: z3.string().min(1)
-}).strict();
-var messagesSummarizedEventDataSchema = z3.object({
-  type: z3.literal("messages_summarized"),
-  historyFromSeq: z3.number().int().nonnegative(),
-  compactions: z3.array(
-    z3.object({
-      coveredMessageCount: z3.number().int().nonnegative(),
-      createdAtMs: z3.number(),
-      id: z3.string().min(1),
-      summary: z3.string()
-    }).strict()
-  )
-}).strict();
-var conversationTurnSurfaceSchema = z3.enum([
-  "slack",
-  "api",
-  "scheduler",
-  "internal"
-]);
-var conversationTurnFailureCodeSchema = z3.enum([
-  "agent_run_failed",
-  "delivery_failed",
-  "model_execution_failed",
-  "persistence_failed"
-]);
-var turnStartedEventDataSchema = z3.object({
-  type: z3.literal("turn_started"),
-  turnId: z3.string().min(1),
-  inputMessageIds: z3.array(z3.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 = z3.object({
-  type: z3.literal("turn_routed"),
-  turnId: z3.string().min(1),
-  modelProfile: modelProfileSchema,
-  modelId: z3.string().min(1),
-  costUsd: z3.number().finite().nonnegative().optional(),
-  reasoningLevel: z3.enum(TURN_REASONING_LEVELS),
-  confidence: z3.number().min(0).max(1).optional(),
-  source: z3.enum(["configured", "inherited", "router"])
-}).strict();
-var turnContextEventDataSchema = z3.object({
-  type: z3.literal("turn_context"),
-  turnId: z3.string().min(1),
-  pluginName: z3.string().min(1),
-  kind: z3.string().min(1).max(64),
-  version: z3.number().int().positive(),
-  content: z3.record(z3.string(), z3.unknown())
-}).strict();
-var structuredConversationEventDataSchema = z3.object({
-  type: z3.literal("structured_event"),
-  namespace: z3.string().regex(/^[a-z][a-z0-9-]*$/),
-  name: z3.string().regex(/^[a-z][a-z0-9_]*$/),
-  version: z3.number().int().positive(),
-  turnId: z3.string().min(1).optional(),
-  content: z3.record(z3.string(), z3.unknown())
-}).strict();
-var deliveredAttachmentSchema = z3.object({
-  id: z3.string().min(1),
-  filename: z3.string().min(1),
-  contentType: z3.string().min(1),
-  bytes: z3.number().int().nonnegative()
-}).strict();
-var attachmentsDeliveredEventDataSchema = z3.object({
-  type: z3.literal("attachments_delivered"),
-  attachments: z3.array(deliveredAttachmentSchema).min(1),
-  toolCallId: z3.string().min(1).optional(),
-  turnId: z3.string().min(1).optional()
-}).strict();
-var turnCompletedEventDataSchema = z3.object({
-  type: z3.literal("turn_completed"),
-  turnId: z3.string().min(1),
-  outcome: z3.enum(["success", "no_reply", "cancelled"])
-}).strict();
-var turnFailedEventDataSchema = z3.object({
-  type: z3.literal("turn_failed"),
-  turnId: z3.string().min(1),
-  failureCode: conversationTurnFailureCodeSchema,
-  eventId: z3.string().regex(/^[a-f0-9]{32}$/i).optional()
-}).strict();
-var subagentStartedEventDataSchema = z3.object({
-  type: z3.literal("subagent_started"),
-  subagentInvocationId: z3.string().min(1),
-  subagentKind: z3.string().min(1),
-  modelId: z3.string().min(1).optional(),
-  parentToolCallId: z3.string().min(1).optional(),
-  reasoningLevel: z3.string().min(1).optional(),
-  childConversationId: z3.string().min(1)
-}).strict();
-var subagentEndedEventDataSchema = z3.object({
-  type: z3.literal("subagent_ended"),
-  subagentInvocationId: z3.string().min(1),
-  outcome: z3.union([
-    z3.literal("success"),
-    z3.literal("error"),
-    z3.literal("aborted")
-  ]),
-  errorCode: z3.string().min(1).optional()
-}).strict();
-var appendableConversationEventDataSchema = z3.union([
-  messageEventDataSchema,
-  messageUpdatedEventDataSchema,
-  agentHistoryItemSchema,
-  mcpProviderConnectedEventDataSchema,
-  authorizationRequestedEventDataSchema,
-  authorizationCompletedEventDataSchema,
-  toolExecutionStartedEventDataSchema,
-  guardianActionReviewedEventDataSchema,
-  messageHandledEventDataSchema,
-  messagesSummarizedEventDataSchema,
-  turnStartedEventDataSchema,
-  turnContextEventDataSchema,
-  structuredConversationEventDataSchema,
-  attachmentsDeliveredEventDataSchema,
-  turnRoutedEventDataSchema,
-  turnCompletedEventDataSchema,
-  turnFailedEventDataSchema,
-  subagentStartedEventDataSchema,
-  subagentEndedEventDataSchema
-]);
-var conversationEventDataSchema = z3.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 = z3.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var unknownConversationEventDataSchema = z3.object({
-  type: z3.literal("unknown"),
-  originalType: z3.string().min(1),
-  payload: z3.unknown()
-}).strict();
-var conversationEventEnvelopeSchema = z3.object({
-  schemaVersion: z3.number().int().nonnegative(),
-  seq: z3.number().int().nonnegative(),
-  historyVersion: z3.number().int().nonnegative(),
-  idempotencyKey: z3.string().min(1).optional(),
-  createdAtMs: z3.number().finite()
-}).strict();
-var conversationEventSchema = z3.union([
-  conversationEventEnvelopeSchema.extend({
-    schemaVersion: z3.literal(1),
-    data: conversationEventDataSchema
-  }),
-  conversationEventEnvelopeSchema.extend({
-    data: unknownConversationEventDataSchema
-  })
-]);
-var storedConversationEventSchema = conversationEventEnvelopeSchema.extend({
-  type: z3.string().min(1),
-  payload: z3.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 = z3.object({
-  data: appendableConversationEventDataSchema,
-  idempotencyKey: z3.string().min(1).optional(),
-  createdAtMs: z3.number().finite()
-}).strict();
-
 // src/chat/conversations/sql/conversation-row.ts
 import { sql as sql4 } from "drizzle-orm";
 async function ensureConversationRow(executor, conversationId, atMs, options = {}) {
@@ -2150,13 +1797,6 @@ export {
   bindProviderConversation,
   locationFromRow,
   withConversationMutationLock,
-  instructionProvenanceFor,
-  contextProvenance,
-  sameActorIdentity,
-  instructionActors,
-  agentHistoryItemSchema,
-  KNOWN_CONVERSATION_EVENT_TYPES,
-  decodeStoredConversationEvent,
   sanitizePostgresJson,
   withConversationEventLock,
   createSqlConversationEventStore,

package/dist/{chunk-LHXIZLFF.js → chunk-64WF2GQ3.js}

@@ -12,7 +12,7 @@ import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/plugins/manifest.ts
 import { z } from "zod";

package/dist/{chunk-YKX6MTLU.js → chunk-7EOWT62G.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   toOptionalString
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";