@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-7NL7T6VU.js

@@ -1,406 +0,0 @@
-import {
-  TURN_REASONING_LEVELS,
-  modelProfileSchema
-} from "./chunk-NHJU2ZAL.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-A76OIMYN.js

@@ -1,102 +0,0 @@
-import {
-  parseSlackChannelId,
-  parseSlackMessageTs,
-  parseSlackTeamId
-} from "./chunk-N7TMSOZH.js";
-import {
-  toOptionalString
-} from "./chunk-MAGNK5J4.js";
-
-// src/chat/slack/context.ts
-import { z } from "zod";
-function toTrimmedSlackString(value) {
-  const normalized = toOptionalString(value);
-  return normalized?.trim() || void 0;
-}
-var slackMessageEnvelopeSchema = z.object({
-  raw: z.unknown().optional()
-});
-var rawSlackMessageSchema = z.object({
-  channel: z.unknown().optional(),
-  message: z.unknown().optional(),
-  team: z.unknown().optional(),
-  team_id: z.unknown().optional(),
-  thread_ts: z.unknown().optional(),
-  ts: z.unknown().optional(),
-  user_team: z.unknown().optional()
-});
-var nestedRawSlackMessageSchema = z.object({
-  ts: z.unknown().optional()
-});
-function readSlackRawMessageContext(message) {
-  const envelope = slackMessageEnvelopeSchema.safeParse(message);
-  if (!envelope.success) {
-    return void 0;
-  }
-  const raw = rawSlackMessageSchema.safeParse(envelope.data.raw);
-  if (!raw.success) {
-    return void 0;
-  }
-  const nestedMessage = nestedRawSlackMessageSchema.safeParse(raw.data.message);
-  const channelId = parseSlackChannelId(raw.data.channel);
-  const threadTs = parseSlackMessageTs(raw.data.thread_ts);
-  const messageTs = parseSlackMessageTs(raw.data.ts);
-  const nestedMessageTs = nestedMessage.success && parseSlackMessageTs(nestedMessage.data.ts);
-  const teamId = parseSlackTeamId(raw.data.team_id) ?? parseSlackTeamId(raw.data.team);
-  const authorTeamId = parseSlackTeamId(raw.data.user_team);
-  return {
-    ...channelId ? { channelId } : void 0,
-    ...threadTs ? { threadTs } : void 0,
-    ...messageTs ? { messageTs } : void 0,
-    ...nestedMessageTs ? { nestedMessageTs } : void 0,
-    ...teamId ? { teamId } : void 0,
-    ...authorTeamId ? { authorTeamId } : void 0
-  };
-}
-function parseSlackThreadId(threadId) {
-  const normalizedThreadId = toTrimmedSlackString(threadId);
-  if (!normalizedThreadId) {
-    return void 0;
-  }
-  const parts = normalizedThreadId.split(":");
-  if (parts.length !== 3 || parts[0] !== "slack") {
-    return void 0;
-  }
-  const channelId = parseSlackChannelId(parts[1]);
-  const threadTs = parseSlackMessageTs(parts[2]);
-  if (!channelId || !threadTs) {
-    return void 0;
-  }
-  return { channelId, threadTs };
-}
-function resolveSlackChannelIdFromThreadId(threadId) {
-  return parseSlackThreadId(threadId)?.channelId;
-}
-function resolveSlackChannelIdFromMessage(message) {
-  const messageChannelId = parseSlackChannelId(
-    message.channelId
-  );
-  if (messageChannelId) {
-    return messageChannelId;
-  }
-  const raw = message.raw;
-  if (raw && typeof raw === "object") {
-    const rawChannel = parseSlackChannelId(
-      raw.channel
-    );
-    if (rawChannel) {
-      return rawChannel;
-    }
-  }
-  const threadId = toTrimmedSlackString(
-    message.threadId
-  );
-  return resolveSlackChannelIdFromThreadId(threadId);
-}
-
-export {
-  readSlackRawMessageContext,
-  parseSlackThreadId,
-  resolveSlackChannelIdFromThreadId,
-  resolveSlackChannelIdFromMessage
-};

package/dist/chunk-AWMS3SPP.js

@@ -1,58 +0,0 @@
-import {
-  ConversationTurnLifecycleService
-} from "./chunk-DBVY6HLX.js";
-import {
-  runAgentWithTimeout
-} from "./chunk-DL2KLKVH.js";
-import {
-  getConversationEventStore
-} from "./chunk-M76HMB7M.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
-};