@sentry/junior 0.184.0 → 0.186.0

package/dist/{chunk-DUKIDPF6.js → chunk-DOP3FIQC.js}

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

package/dist/{chunk-BT53RIGJ.js → chunk-EWRPUXE3.js}

@@ -1,11 +1,15 @@
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-GQMQCY7H.js";
 import {
   ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+} from "./chunk-STOCCPWH.js";
 import {
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-E57WPXWY.js";
+} from "./chunk-CM6RTYSO.js";
 import {
   AgentInvocationBusyError,
   AgentInvocationLimitError,
@@ -14,78 +18,36 @@ import {
   agentBindingSchema,
   agentInvocationSchema,
   createAgentInvocationSchema
-} from "./chunk-K7VDC2QW.js";
+} from "./chunk-TXLBLGNQ.js";
 import {
   appendAndEnqueueInboundMessage
-} from "./chunk-Z3QAXJR7.js";
+} from "./chunk-2IBDVE62.js";
 import {
   TurnInputCommitLostError,
   getAssistantReplyText,
   getConversationTurnBoundaryError,
   isTurnInputCommitLostError
-} from "./chunk-JA43DV4Y.js";
+} from "./chunk-VOGOTEW7.js";
 import {
   failTurnRecord,
   getTerminalAssistantMessages,
   getTurnRecord,
   openConversationProjection,
   saveTurnCheckpoint
-} from "./chunk-2ZQPVX7C.js";
+} from "./chunk-H7X2G2KS.js";
 import {
   getConversationEventStore,
   getConversationStore,
   getSqlExecutor
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-43LODHJM.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations
-} from "./chunk-BCHYQS4B.js";
+} from "./chunk-VXL2LBPK.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";

package/dist/{chunk-BHYRYYLY.js → chunk-FFYDRLXW.js}

@@ -1,6 +1,6 @@
 import {
   logWarn
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/conversation-privacy.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-GQMQCY7H.js

@@ -0,0 +1,58 @@
+import {
+  ConversationTurnLifecycleService
+} from "./chunk-STOCCPWH.js";
+import {
+  runAgentWithTimeout
+} from "./chunk-INQHUE72.js";
+import {
+  getConversationEventStore
+} from "./chunk-43LODHJM.js";
+
+// 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, timeoutMs) {
+  let outcome;
+  try {
+    outcome = await runAgentWithTimeout(agentRunner, run, timeoutMs);
+  } 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,
+      ...saved.eventId ? { eventId: saved.eventId } : void 0,
+      failureCode: saved.failureCode,
+      ...saved.failureReason ? { failureReason: saved.failureReason } : void 0
+    });
+  } else {
+    await lifecycle.complete({
+      ...common,
+      outcome: saved.outcome
+    });
+  }
+  return { status: "completed" };
+}
+
+export {
+  AgentRunError,
+  executeTurn
+};