@sentry/junior 0.203.0 → 0.204.0

package/dist/chunk-MTM5IFCY.js

@@ -1,1190 +0,0 @@
-import {
-  usageSchema
-} from "./chunk-PDO5BLNM.js";
-import {
-  conversationTurnFailureCodeSchema,
-  conversationTurnFailureReasonSchema
-} from "./chunk-7NL7T6VU.js";
-import {
-  juniorDestinationKindSchema
-} from "./chunk-VFUK3X5B.js";
-
-// src/api/activity.ts
-import { z } from "zod";
-
-// src/api/reporting-window.ts
-var HOUR_MS = 60 * 60 * 1e3;
-var SIX_HOUR_MS = 6 * HOUR_MS;
-var DAY_MS = 24 * HOUR_MS;
-var WINDOW_HOURS = 24;
-var WINDOW_SEVEN_DAY_HOURS = 7 * 24;
-var WINDOW_SIX_HOURS = 7 * 4;
-function startOfUtcDay(valueMs) {
-  const date = new Date(valueMs);
-  date.setUTCHours(0, 0, 0, 0);
-  return date;
-}
-function startOfUtcHour(valueMs) {
-  const date = new Date(valueMs);
-  date.setUTCMinutes(0, 0, 0);
-  return date;
-}
-function startOfUtcSixHour(valueMs) {
-  const date = startOfUtcHour(valueMs);
-  date.setUTCHours(Math.floor(date.getUTCHours() / 6) * 6, 0, 0, 0);
-  return date;
-}
-function utcDayKey(value) {
-  const date = typeof value === "number" ? new Date(value) : value;
-  return date.toISOString().slice(0, 10);
-}
-function utcHourKey(value) {
-  const date = typeof value === "number" ? new Date(value) : value;
-  return date.toISOString().slice(0, 13);
-}
-function utcSixHourKey(value) {
-  return utcHourKey(startOfUtcSixHour(
-    typeof value === "number" ? value : value.getTime()
-  ));
-}
-function trailingUtcDayWindow(nowMs, dayCount) {
-  const end = startOfUtcDay(nowMs);
-  const start = new Date(end);
-  start.setUTCDate(start.getUTCDate() - (dayCount - 1));
-  return { end, start };
-}
-function trailingUtcHourWindow(nowMs, hourCount = WINDOW_HOURS) {
-  const end = startOfUtcHour(nowMs);
-  const start = new Date(end.getTime() - (hourCount - 1) * HOUR_MS);
-  return { end, start };
-}
-function trailingUtcSixHourWindow(nowMs, bucketCount = WINDOW_SIX_HOURS) {
-  const end = startOfUtcSixHour(nowMs);
-  const start = new Date(end.getTime() - (bucketCount - 1) * SIX_HOUR_MS);
-  return { end, start };
-}
-function fillUtcDays(args) {
-  const { end, start } = trailingUtcDayWindow(args.nowMs, args.count);
-  const items = [];
-  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
-    const date = utcDayKey(cursor);
-    items.push(args.rows.get(date) ?? args.empty(date));
-  }
-  return items;
-}
-function fillUtcHours(args) {
-  const hourCount = args.count ?? WINDOW_HOURS;
-  const { end, start } = trailingUtcHourWindow(args.nowMs, hourCount);
-  const items = [];
-  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setTime(cursor.getTime() + HOUR_MS)) {
-    const date = utcHourKey(cursor);
-    items.push(args.rows.get(date) ?? args.empty(date));
-  }
-  return items;
-}
-function fillUtcSixHours(args) {
-  const bucketCount = args.count ?? WINDOW_SIX_HOURS;
-  const { end, start } = trailingUtcSixHourWindow(args.nowMs, bucketCount);
-  const items = [];
-  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setTime(cursor.getTime() + SIX_HOUR_MS)) {
-    const date = utcSixHourKey(cursor);
-    items.push(args.rows.get(date) ?? args.empty(date));
-  }
-  return items;
-}
-function sumUtcHoursIntoSixHours(args) {
-  const bucketCount = args.count ?? WINDOW_SIX_HOURS;
-  const bySix = /* @__PURE__ */ new Map();
-  for (const hour of args.hours) {
-    const key = utcSixHourKey(Date.parse(`${hour.date}:00:00.000Z`));
-    const current = bySix.get(key) ?? args.empty(key);
-    const next = { ...current, date: key };
-    for (const [field, value] of Object.entries(hour)) {
-      if (field === "date") continue;
-      if (typeof value === "number") {
-        const prior = next[field];
-        next[field] = (typeof prior === "number" ? prior : 0) + value;
-      }
-    }
-    bySix.set(key, next);
-  }
-  return fillUtcSixHours({
-    count: bucketCount,
-    empty: args.empty,
-    nowMs: args.nowMs,
-    rows: bySix
-  });
-}
-
-// src/api/activity.ts
-var dailyConversationActivitySchema = z.object({
-  active: z.number(),
-  conversations: z.number(),
-  date: z.string(),
-  durationMs: z.number(),
-  failed: z.number(),
-  tokens: z.number().optional()
-}).strict();
-function emptyActivityDay(date) {
-  return {
-    active: 0,
-    conversations: 0,
-    date,
-    durationMs: 0,
-    failed: 0
-  };
-}
-function activityDays(days, nowMs, count) {
-  return fillUtcDays({
-    count,
-    empty: emptyActivityDay,
-    nowMs,
-    rows: days
-  });
-}
-function activityHours(hours, nowMs) {
-  return fillUtcHours({
-    count: WINDOW_SEVEN_DAY_HOURS,
-    empty: emptyActivityDay,
-    nowMs,
-    rows: hours
-  });
-}
-function activitySixHours(hours, nowMs) {
-  const series = hours instanceof Map ? activityHours(hours, nowMs) : [...hours];
-  return sumUtcHoursIntoSixHours({
-    empty: emptyActivityDay,
-    hours: series,
-    nowMs
-  });
-}
-
-// src/api/schema/code.ts
-import { z as z2 } from "zod";
-import { codeChangeStateSchema } from "@sentry/junior-plugin-api";
-var codeChangeSummarySchema = z2.object({
-  closed: z2.number().int().nonnegative(),
-  costUsd: z2.number().nonnegative().optional(),
-  created: z2.number().int().nonnegative(),
-  medianCostUsd: z2.number().nonnegative().optional(),
-  medianMergeTimeMs: z2.number().nonnegative().optional(),
-  merged: z2.number().int().nonnegative(),
-  mergeRate: z2.number().min(0).max(1).optional(),
-  open: z2.number().int().nonnegative()
-}).strict();
-var codeMetricBucketSchema = z2.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
-var codeActivityDaySchema = z2.object({
-  closed: z2.number().int().nonnegative(),
-  created: z2.number().int().nonnegative(),
-  date: codeMetricBucketSchema,
-  merged: z2.number().int().nonnegative()
-}).strict();
-var codeRepositorySummarySchema = z2.object({
-  closed: z2.number().int().nonnegative(),
-  created: z2.number().int().nonnegative(),
-  id: z2.string().uuid(),
-  medianCostUsd: z2.number().nonnegative().optional(),
-  merged: z2.number().int().nonnegative(),
-  mergeRate: z2.number().min(0).max(1).optional(),
-  name: z2.string().min(1),
-  open: z2.number().int().nonnegative(),
-  provider: z2.string().min(1),
-  url: z2.string().url().optional()
-}).strict();
-var codeChangeSummaryReportSchema = z2.object({
-  closedAt: z2.string().optional(),
-  id: z2.string().uuid(),
-  mergedAt: z2.string().optional(),
-  number: z2.number().int().positive(),
-  openedAt: z2.string(),
-  provider: z2.string().min(1),
-  repository: z2.string().min(1),
-  state: codeChangeStateSchema,
-  title: z2.string().optional(),
-  url: z2.string().url().optional()
-}).strict();
-var codeOverviewReportSchema = z2.object({
-  activityDays: z2.array(codeActivityDaySchema),
-  activityHours: z2.array(codeActivityDaySchema).optional(),
-  activitySixHours: z2.array(codeActivityDaySchema).optional(),
-  changes: z2.array(codeChangeSummaryReportSchema),
-  generatedAt: z2.string(),
-  repositories: z2.array(codeRepositorySummarySchema),
-  summary: codeChangeSummarySchema,
-  windowEnd: z2.string(),
-  windowStart: z2.string()
-}).strict();
-var codePersonReportSchema = z2.object({
-  activityDays: z2.array(codeActivityDaySchema),
-  activityHours: z2.array(codeActivityDaySchema).optional(),
-  activitySixHours: z2.array(codeActivityDaySchema).optional(),
-  generatedAt: z2.string(),
-  summary: codeChangeSummarySchema,
-  windowEnd: z2.string(),
-  windowStart: z2.string()
-}).strict();
-
-// src/api/schema/conversation.ts
-import { z as z3 } from "zod";
-import {
-  conversationAnnotationInputSchema,
-  conversationSidebarAnnotationSchema,
-  conversationEventPresentationSchema
-} from "@sentry/junior-plugin-api";
-var conversationReportStatusSchema = z3.enum([
-  "active",
-  "completed",
-  "failed"
-]);
-var conversationSurfaceSchema = z3.enum([
-  "api",
-  "internal",
-  "scheduler",
-  "slack"
-]);
-var conversationUsageSchema = usageSchema;
-var conversationParamsSchema = z3.object({ conversationId: z3.string().min(1) }).strict();
-var conversationAttachmentParamsSchema = z3.object({
-  attachmentId: z3.string().min(1),
-  conversationId: z3.string().min(1)
-}).strict();
-var conversationDetailQuerySchema = z3.object({
-  limit: z3.coerce.number().int().min(1).max(1e3).default(500)
-}).strict();
-var conversationEventsQuerySchema = z3.object({
-  before: z3.string().min(1),
-  limit: z3.coerce.number().int().min(1).max(1e3).default(500)
-}).strict();
-var conversationFeedQuerySchema = z3.object({
-  actorEmail: z3.string().trim().email().transform((value) => value.toLowerCase()).optional(),
-  status: z3.enum(["active", "archived"]).default("active")
-}).strict();
-var archiveConversationBodySchema = z3.object({ archived: z3.boolean(), lastSeenAt: z3.string().datetime() }).strict();
-var archiveConversationResponseSchema = z3.object({ archivedAt: z3.string().datetime().nullable() }).strict();
-var createConversationBodySchema = z3.object({
-  idempotencyKey: z3.string().trim().min(1).max(200),
-  message: z3.string().trim().min(1).max(32e3),
-  /** New roots default public. Private roots stay participant-only. */
-  visibility: z3.enum(["private", "public"]).optional()
-}).strict();
-var createConversationMessageBodySchema = z3.object({
-  idempotencyKey: z3.string().trim().min(1).max(200),
-  message: z3.string().trim().min(1).max(32e3)
-}).strict();
-var acceptedConversationMessageSchema = z3.object({
-  conversationId: z3.string().min(1),
-  messageId: z3.string().min(1),
-  status: z3.enum(["accepted", "duplicate"])
-}).strict();
-var actorIdentitySchema = z3.object({
-  email: z3.string().optional(),
-  fullName: z3.string().optional(),
-  slackUserId: z3.string().optional(),
-  slackUserName: z3.string().optional()
-}).strict();
-var conversationPendingMessageDeliverySchema = z3.enum([
-  "defer",
-  "interrupt"
-]);
-var conversationPendingMessageSchema = z3.object({
-  actorIdentity: actorIdentitySchema.optional(),
-  createdAt: z3.string().datetime(),
-  delivery: conversationPendingMessageDeliverySchema,
-  inboundMessageId: z3.string().min(1),
-  messageId: z3.string().min(1),
-  receivedAt: z3.string().datetime(),
-  role: z3.literal("user"),
-  source: z3.enum(["slack", "web"]),
-  text: z3.string().optional(),
-  redacted: z3.literal(true).optional()
-}).strict().superRefine((data, context) => {
-  if (data.text === void 0 === (data.redacted !== true)) {
-    context.addIssue({
-      code: "custom",
-      message: "pending message content must be text or explicitly redacted"
-    });
-  }
-  if (data.redacted && data.actorIdentity) {
-    context.addIssue({
-      code: "custom",
-      message: "redacted pending messages must not expose actor identity"
-    });
-  }
-});
-var conversationPendingAuthorizationSchema = z3.object({
-  authorizationUrl: z3.string().url(),
-  completionText: z3.string().min(1),
-  label: z3.string().min(1)
-}).strict();
-var conversationPendingMessagesReportSchema = z3.object({
-  authorization: conversationPendingAuthorizationSchema.optional(),
-  conversationId: z3.string().min(1),
-  generatedAt: z3.string().datetime(),
-  messages: z3.array(conversationPendingMessageSchema)
-}).strict();
-var cancelConversationPendingMessagesBodySchema = z3.object({
-  inboundMessageIds: z3.array(z3.string().min(1)).min(1).optional(),
-  receivedBefore: z3.string().datetime().optional()
-}).strict();
-var cancelConversationPendingMessagesResponseSchema = z3.object({
-  cancelledCount: z3.number().int().nonnegative(),
-  cancelledInboundMessageIds: z3.array(z3.string().min(1)),
-  conversationId: z3.string().min(1)
-}).strict();
-var conversationAuxiliaryCostsSchema = z3.object({
-  costUsd: z3.number().finite().nonnegative(),
-  operations: z3.array(
-    z3.object({
-      costUsd: z3.number().finite().nonnegative(),
-      events: z3.number().int().positive(),
-      name: z3.string().min(1),
-      namespace: z3.string().min(1)
-    }).strict()
-  ).min(1)
-}).strict();
-var conversationSourceTaskSchema = z3.object({
-  id: z3.string().min(1).optional(),
-  kind: z3.enum(["scheduled", "event"]),
-  label: z3.string().min(1).optional(),
-  title: z3.string().min(1).optional()
-}).strict().superRefine((value, context) => {
-  if (Boolean(value.id) !== Boolean(value.label)) {
-    context.addIssue({
-      code: "custom",
-      message: "sourceTask id and label must both be set or both omitted"
-    });
-  }
-});
-var conversationAnnotationReportSchema = conversationAnnotationInputSchema.and(
-  z3.object({
-    plugin: z3.string().min(1),
-    createdAt: z3.string().datetime(),
-    updatedAt: z3.string().datetime()
-  })
-);
-var conversationSummaryReportSchema = z3.object({
-  displayTitle: z3.string(),
-  cumulativeDurationMs: z3.number(),
-  cumulativeUsage: conversationUsageSchema.optional(),
-  auxiliaryCosts: conversationAuxiliaryCostsSchema.optional(),
-  conversationId: z3.string(),
-  isParticipant: z3.boolean(),
-  visibility: z3.enum(["private", "public"]).optional(),
-  status: conversationReportStatusSchema,
-  startedAt: z3.string(),
-  lastSeenAt: z3.string(),
-  lastProgressAt: z3.string(),
-  surface: conversationSurfaceSchema,
-  actorIdentity: actorIdentitySchema.optional(),
-  archivedAt: z3.string().datetime().nullable().optional(),
-  channel: z3.string().optional(),
-  channelName: z3.string().optional(),
-  channelNameRedacted: z3.boolean().optional(),
-  locationId: z3.string().optional(),
-  sentryTraceUrl: z3.string().optional(),
-  locationUrl: z3.string().url().optional(),
-  traceId: z3.string().optional(),
-  /**
-   * Plugin-owned resource links for this conversation.
-   * Present on the conversation feed when the viewer can see private content.
-   * Clients must not fetch provider state while rendering these links.
-   */
-  annotations: z3.array(conversationAnnotationReportSchema).optional(),
-  /** Plugin-selected annotations for the compact conversation row. */
-  sidebarAnnotations: z3.array(conversationSidebarAnnotationSchema).optional(),
-  assignedWork: z3.boolean().optional(),
-  finishedWorkAt: z3.string().datetime().optional(),
-  /**
-   * Dashboard Priority membership for this conversation summary.
-   * Present on the conversation feed. Clients must not recompute it.
-   *
-   * True only when:
-   * - unfinished work was last seen within 48 hours
-   * - finished assigned work has conversation activity after the finish time
-   * - there is no known work and the conversation was last seen within 3 hours
-   */
-  isPriority: z3.boolean().optional(),
-  unfinishedWork: z3.boolean().optional()
-}).strict();
-var conversationReportMessageEventDataSchema = z3.object({
-  type: z3.literal("message"),
-  messageId: z3.string().min(1),
-  role: z3.enum(["assistant", "system", "user"]),
-  source: z3.enum(["slack", "web"]).optional(),
-  actorIdentity: actorIdentitySchema.optional(),
-  eventType: z3.string().min(1).optional(),
-  explicitMention: z3.boolean().optional(),
-  trustedSummary: z3.string().min(1).optional(),
-  text: z3.string().optional(),
-  redacted: z3.literal(true).optional()
-}).strict().superRefine((data, context) => {
-  if (data.text === void 0 === (data.redacted !== true)) {
-    context.addIssue({
-      code: "custom",
-      message: "message content must be text or explicitly redacted"
-    });
-  }
-  if (data.redacted && data.actorIdentity) {
-    context.addIssue({
-      code: "custom",
-      message: "redacted messages must not expose actor identity"
-    });
-  }
-});
-var conversationReportMessageHandledEventDataSchema = z3.object({
-  type: z3.literal("message_handled"),
-  messageId: z3.string().min(1)
-}).strict();
-var conversationReportToolCallSchema = z3.object({
-  toolCallId: z3.string().min(1),
-  name: z3.string().min(1),
-  status: z3.enum(["running", "completed", "error"]),
-  startedAt: z3.string().datetime().optional(),
-  startedSeq: z3.number().int().nonnegative().optional(),
-  input: z3.unknown().optional(),
-  output: z3.unknown().optional()
-}).strict().superRefine((call, context) => {
-  if (call.startedAt === void 0 !== (call.startedSeq === void 0)) {
-    context.addIssue({
-      code: "custom",
-      message: "tool start sequence and timestamp must be provided together"
-    });
-  }
-});
-var conversationReportReasoningPartSchema = z3.object({
-  type: z3.literal("reasoning"),
-  text: z3.string().min(1).optional(),
-  redacted: z3.literal(true).optional()
-}).strict().superRefine((data, context) => {
-  if (data.text === void 0 === (data.redacted !== true)) {
-    context.addIssue({
-      code: "custom",
-      message: "reasoning content must be text or explicitly redacted"
-    });
-  }
-});
-var conversationReportAssistantToolCallPartSchema = z3.object({
-  type: z3.literal("tool_call"),
-  toolCallId: z3.string().min(1)
-}).strict();
-var conversationReportAssistantMetadataSchema = z3.object({
-  parts: z3.array(
-    z3.discriminatedUnion("type", [
-      conversationReportReasoningPartSchema,
-      conversationReportAssistantToolCallPartSchema
-    ])
-  ).min(1)
-}).strict();
-var conversationReportToolCallsEventDataSchema = z3.object({
-  type: z3.literal("tool_calls"),
-  calls: z3.array(conversationReportToolCallSchema).min(1),
-  assistant: conversationReportAssistantMetadataSchema.optional()
-}).strict().superRefine((data, context) => {
-  if (!data.assistant) return;
-  const callCounts = /* @__PURE__ */ new Map();
-  for (const call of data.calls) {
-    callCounts.set(
-      call.toolCallId,
-      (callCounts.get(call.toolCallId) ?? 0) + 1
-    );
-  }
-  const partCounts = /* @__PURE__ */ new Map();
-  for (const part of data.assistant.parts) {
-    if (part.type !== "tool_call") continue;
-    partCounts.set(
-      part.toolCallId,
-      (partCounts.get(part.toolCallId) ?? 0) + 1
-    );
-  }
-  if (callCounts.size !== partCounts.size || [...callCounts].some(
-    ([toolCallId, count]) => partCounts.get(toolCallId) !== count
-  )) {
-    context.addIssue({
-      code: "custom",
-      path: ["assistant", "parts"],
-      message: "assistant tool parts must reference every call exactly once"
-    });
-  }
-});
-var conversationReportAssistantMessageEventDataSchema = z3.object({
-  type: z3.literal("assistant_message"),
-  parts: z3.array(conversationReportReasoningPartSchema).min(1)
-}).strict();
-var conversationReportTurnLifecycleEventDataSchema = z3.discriminatedUnion(
-  "state",
-  [
-    z3.object({
-      type: z3.literal("turn_lifecycle"),
-      turnId: z3.string().min(1),
-      state: z3.enum(["succeeded", "no_reply"])
-    }).strict(),
-    z3.object({
-      type: z3.literal("turn_lifecycle"),
-      turnId: z3.string().min(1),
-      state: z3.literal("started"),
-      inputMessageIds: z3.array(z3.string().min(1)).min(1).optional()
-    }).strict(),
-    z3.object({
-      type: z3.literal("turn_lifecycle"),
-      turnId: z3.string().min(1),
-      state: z3.literal("failed"),
-      failureCode: conversationTurnFailureCodeSchema,
-      failureReason: conversationTurnFailureReasonSchema.optional(),
-      eventId: z3.string().regex(/^[a-f0-9]{32}$/i).optional(),
-      sentryEventUrl: z3.string().url().optional()
-    }).strict()
-  ]
-);
-var conversationReportTurnRoutedEventDataSchema = z3.object({
-  type: z3.literal("turn_routed"),
-  turnId: z3.string().min(1),
-  modelProfile: z3.string().min(1),
-  modelId: z3.string().min(1),
-  costUsd: z3.number().finite().nonnegative().optional(),
-  reasoningLevel: z3.string().min(1),
-  confidence: z3.number().min(0).max(1).optional(),
-  source: z3.enum(["configured", "inherited", "router"])
-}).strict();
-var conversationReportGuardianActionReviewedEventDataSchema = z3.object({
-  type: z3.literal("guardian_action_reviewed"),
-  turnId: z3.string().min(1),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1),
-  decision: z3.enum(["allow", "ask", "deny"]),
-  riskLevel: z3.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z3.enum(["high", "medium", "low", "unknown"])
-}).strict();
-var conversationReportTurnContextEventDataSchema = z3.object({
-  type: z3.literal("turn_context"),
-  turnId: z3.string().min(1),
-  pluginName: z3.string().min(1),
-  kind: z3.string().min(1),
-  version: z3.number().int().positive(),
-  content: z3.record(z3.string(), z3.unknown())
-}).strict();
-var conversationReportStructuredEventDataSchema = z3.object({
-  type: z3.literal("structured_event"),
-  namespace: z3.string().min(1),
-  name: z3.string().min(1),
-  version: z3.number().int().positive(),
-  turnId: z3.string().min(1).optional(),
-  presentation: conversationEventPresentationSchema
-}).strict();
-var conversationReportDeliveredAttachmentSchema = z3.object({
-  id: z3.string().min(1),
-  filename: z3.string().min(1),
-  contentType: z3.string().min(1),
-  bytes: z3.number().int().nonnegative()
-}).strict();
-var conversationReportAttachmentsDeliveredEventDataSchema = z3.object({
-  type: z3.literal("attachments_delivered"),
-  attachments: z3.array(conversationReportDeliveredAttachmentSchema).min(1)
-}).strict();
-var conversationReportCompactionEventDataSchema = z3.object({
-  type: z3.literal("compaction"),
-  modelProfile: z3.string().min(1).optional(),
-  modelId: z3.string().min(1).optional(),
-  summary: z3.string().min(1).optional(),
-  details: 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().optional()
-}).strict();
-var conversationReportHandoffEventDataSchema = z3.object({
-  type: z3.literal("handoff"),
-  modelProfile: z3.string().min(1),
-  modelId: z3.string().min(1),
-  reasoningLevel: z3.string().min(1).optional(),
-  triggeringToolCallId: z3.string().min(1).optional(),
-  summary: z3.string().min(1).optional()
-}).strict();
-var conversationReportSubagentEventDataSchema = z3.object({
-  type: z3.literal("subagent"),
-  startedSeq: z3.number().int().nonnegative(),
-  startedAt: z3.string().datetime(),
-  childConversationId: z3.string().min(1),
-  subagentKind: z3.string().min(1),
-  parentToolCallId: z3.string().min(1).optional(),
-  status: z3.enum(["running", "completed", "error", "aborted"])
-}).strict();
-var conversationReportEventDataSchema = z3.discriminatedUnion("type", [
-  conversationReportMessageEventDataSchema,
-  conversationReportMessageHandledEventDataSchema,
-  conversationReportAssistantMessageEventDataSchema,
-  conversationReportToolCallsEventDataSchema,
-  conversationReportTurnLifecycleEventDataSchema,
-  conversationReportTurnContextEventDataSchema,
-  conversationReportStructuredEventDataSchema,
-  conversationReportAttachmentsDeliveredEventDataSchema,
-  conversationReportTurnRoutedEventDataSchema,
-  conversationReportGuardianActionReviewedEventDataSchema,
-  conversationReportCompactionEventDataSchema,
-  conversationReportHandoffEventDataSchema,
-  conversationReportSubagentEventDataSchema
-]);
-var conversationReportEventSchema = z3.object({
-  seq: z3.number().int().nonnegative(),
-  createdAt: z3.string().datetime(),
-  data: conversationReportEventDataSchema
-}).strict();
-var conversationEventHistorySchema = z3.discriminatedUnion("status", [
-  z3.object({ status: z3.literal("available") }).strict(),
-  z3.object({
-    status: z3.literal("redacted"),
-    reason: z3.literal("non_public_conversation")
-  }).strict(),
-  z3.object({
-    status: z3.literal("expired"),
-    expiredAt: z3.string().datetime()
-  }).strict()
-]);
-var conversationModelUsageSchema = z3.object({
-  modelId: z3.string(),
-  usage: conversationUsageSchema
-}).strict();
-function validateConversationEvents(report, context) {
-  if (report.eventHistory.status === "expired" && report.events.length > 0) {
-    context.addIssue({
-      code: "custom",
-      path: ["events"],
-      message: "expired event history must not contain events"
-    });
-  }
-  for (let index = 1; index < report.events.length; index += 1) {
-    if (report.events[index].seq <= report.events[index - 1].seq) {
-      context.addIssue({
-        code: "custom",
-        path: ["events", index, "seq"],
-        message: "report event sequences must be strictly increasing"
-      });
-    }
-  }
-  for (const [index, event] of report.events.entries()) {
-    if (event.data.type === "message") {
-      if (report.eventHistory.status === "redacted" && event.data.redacted !== true) {
-        context.addIssue({
-          code: "custom",
-          path: ["events", index, "data"],
-          message: "redacted event history must redact messages"
-        });
-      }
-      if (report.eventHistory.status === "available" && event.data.redacted === true) {
-        context.addIssue({
-          code: "custom",
-          path: ["events", index, "data"],
-          message: "available event history must expose messages"
-        });
-      }
-    }
-    if (report.eventHistory.status === "redacted" && event.data.type === "tool_calls" && event.data.calls.some(
-      (call) => call.input !== void 0 || call.output !== void 0
-    )) {
-      context.addIssue({
-        code: "custom",
-        path: ["events", index, "data"],
-        message: "redacted event history must redact tool payloads"
-      });
-    }
-    if (report.eventHistory.status === "redacted" && event.data.type === "assistant_message" && event.data.parts.some((part) => part.text !== void 0)) {
-      context.addIssue({
-        code: "custom",
-        path: ["events", index, "data"],
-        message: "redacted event history must redact assistant messages"
-      });
-    }
-    if (report.eventHistory.status === "available" && event.data.type === "assistant_message" && event.data.parts.some((part) => part.redacted === true)) {
-      context.addIssue({
-        code: "custom",
-        path: ["events", index, "data"],
-        message: "available event history must expose reasoning"
-      });
-    }
-    if (event.data.type === "tool_calls" && (report.eventHistory.status === "redacted" && event.data.assistant?.parts.some(
-      (part) => part.type === "reasoning" && part.text !== void 0
-    ) || report.eventHistory.status === "available" && event.data.assistant?.parts.some(
-      (part) => part.type === "reasoning" && part.redacted === true
-    ))) {
-      context.addIssue({
-        code: "custom",
-        path: ["events", index, "data", "assistant"],
-        message: "assistant reasoning must match event history visibility"
-      });
-    }
-  }
-}
-var conversationDetailReportSchema = conversationSummaryReportSchema.extend({
-  modelUsage: z3.array(conversationModelUsageSchema).optional(),
-  events: z3.array(conversationReportEventSchema),
-  eventHistory: conversationEventHistorySchema,
-  previousCursor: z3.string().min(1).optional(),
-  generatedAt: z3.string(),
-  sentryConversationUrl: z3.string().optional(),
-  sourceTask: conversationSourceTaskSchema.optional()
-}).strict().superRefine(validateConversationEvents);
-var conversationEventPageSchema = z3.object({
-  events: z3.array(conversationReportEventSchema),
-  eventHistory: conversationEventHistorySchema,
-  previousCursor: z3.string().min(1).optional(),
-  generatedAt: z3.string()
-}).strict().superRefine(validateConversationEvents);
-var conversationFeedSchema = z3.object({
-  conversations: z3.array(conversationSummaryReportSchema),
-  source: z3.literal("conversation_index"),
-  generatedAt: z3.string()
-}).strict();
-var conversationStatsItemSchema = z3.object({
-  active: z3.number(),
-  conversations: z3.number(),
-  durationMs: z3.number(),
-  failed: z3.number(),
-  label: z3.string(),
-  costUsd: z3.number().optional(),
-  tokens: z3.number().optional()
-}).strict();
-var conversationMetricBucketSchema = z3.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
-var conversationMetricDaySchema = z3.object({
-  cachedInputTokens: z3.number().optional(),
-  conversations: z3.number(),
-  costUsd: z3.number().optional(),
-  date: conversationMetricBucketSchema,
-  durationMs: z3.number(),
-  inputTokens: z3.number().optional(),
-  tokens: z3.number().optional()
-}).strict();
-var guardianMetricDaySchema = z3.object({
-  allow: z3.number(),
-  ask: z3.number(),
-  costUsd: z3.number().optional(),
-  date: conversationMetricBucketSchema,
-  deny: z3.number(),
-  requests: z3.number()
-}).strict();
-var guardianStatsSchema = z3.object({
-  allow: z3.number(),
-  ask: z3.number(),
-  costUsd: z3.number().optional(),
-  deny: z3.number(),
-  metricDays: z3.array(guardianMetricDaySchema),
-  metricHours: z3.array(guardianMetricDaySchema).optional(),
-  metricSixHours: z3.array(guardianMetricDaySchema).optional(),
-  requests: z3.number()
-}).strict();
-var conversationStatsReportSchema = z3.object({
-  active: z3.number(),
-  cachedInputTokens: z3.number().optional(),
-  conversations: z3.number(),
-  durationMs: z3.number(),
-  failed: z3.number(),
-  generatedAt: z3.string(),
-  guardian: guardianStatsSchema,
-  metricDays: z3.array(conversationMetricDaySchema),
-  metricHours: z3.array(conversationMetricDaySchema).optional(),
-  metricSixHours: z3.array(conversationMetricDaySchema).optional(),
-  locations: z3.array(conversationStatsItemSchema),
-  actors: z3.array(conversationStatsItemSchema),
-  source: z3.literal("conversation_index"),
-  costUsd: z3.number().optional(),
-  inputTokens: z3.number().optional(),
-  tokens: z3.number().optional(),
-  windowEnd: z3.string(),
-  windowStart: z3.string()
-}).strict();
-
-// src/api/schema/person.ts
-import { z as z4 } from "zod";
-var personParamsSchema = z4.object({ email: z4.string().trim().min(1) }).strict();
-var peopleConversationStatsItemSchema = conversationStatsItemSchema.omit({ costUsd: true });
-var peopleMetricBucketSchema = z4.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
-var actorActivityDayReportSchema = z4.object({
-  active: z4.number(),
-  conversations: z4.number(),
-  costUsd: z4.number().optional(),
-  date: peopleMetricBucketSchema,
-  durationMs: z4.number(),
-  failed: z4.number(),
-  tokens: z4.number().optional()
-}).strict();
-var peopleActivityDayReportSchema = z4.object({
-  activePeople: z4.number(),
-  conversations: z4.number(),
-  date: peopleMetricBucketSchema
-}).strict();
-var actorTotalsReportSchema = z4.object({
-  active: z4.number(),
-  activeDays: z4.number(),
-  conversations: z4.number(),
-  durationMs: z4.number(),
-  failed: z4.number(),
-  tokens: z4.number().optional()
-}).strict();
-var actorWindowMetricsSchema = z4.object({
-  conversations: z4.number().int().nonnegative(),
-  costUsd: z4.number().finite().nonnegative(),
-  durationMs: z4.number().finite().nonnegative(),
-  priorCostUsd: z4.number().finite().nonnegative()
-}).strict();
-var actorDirectoryWindowsSchema = z4.object({
-  1: actorWindowMetricsSchema,
-  7: actorWindowMetricsSchema,
-  30: actorWindowMetricsSchema,
-  90: actorWindowMetricsSchema
-}).strict();
-var identifiedActorSchema = actorIdentitySchema.extend({ email: z4.string().min(1) }).strict();
-var actorSummaryReportSchema = actorTotalsReportSchema.extend({
-  firstSeenAt: z4.string(),
-  lastSeenAt: z4.string(),
-  actor: identifiedActorSchema,
-  windows: actorDirectoryWindowsSchema
-}).strict();
-var actorDirectoryReportSchema = z4.object({
-  activityDays: z4.array(peopleActivityDayReportSchema),
-  activityHours: z4.array(peopleActivityDayReportSchema).optional(),
-  activitySixHours: z4.array(peopleActivityDayReportSchema).optional(),
-  generatedAt: z4.string(),
-  people: z4.array(actorSummaryReportSchema),
-  source: z4.literal("conversation_index"),
-  windowEnd: z4.string(),
-  windowStart: z4.string()
-}).strict();
-var actorProfileReportSchema = z4.object({
-  activityDays: z4.array(actorActivityDayReportSchema),
-  activityHours: z4.array(actorActivityDayReportSchema).optional(),
-  activitySixHours: z4.array(actorActivityDayReportSchema).optional(),
-  generatedAt: z4.string(),
-  locations: z4.array(peopleConversationStatsItemSchema),
-  recentConversations: z4.array(conversationSummaryReportSchema),
-  actor: identifiedActorSchema,
-  source: z4.literal("conversation_index"),
-  surfaces: z4.array(peopleConversationStatsItemSchema),
-  totals: actorTotalsReportSchema,
-  windowEnd: z4.string(),
-  windowStart: z4.string()
-}).strict();
-var personalSpendReportSchema = z4.object({
-  generatedAt: z4.string(),
-  sevenDaysUsd: z4.number().finite().nonnegative(),
-  source: z4.literal("conversation_index"),
-  thirtyDaysUsd: z4.number().finite().nonnegative(),
-  windowEnd: z4.string(),
-  windowStart: z4.string()
-}).strict();
-
-// src/api/schema/location.ts
-import { z as z5 } from "zod";
-var locationParamsSchema = z5.object({ locationId: z5.string().min(1) }).strict();
-var locationSummaryReportSchema = conversationStatsItemSchema.extend({
-  id: z5.string(),
-  firstSeenAt: z5.string(),
-  kind: juniorDestinationKindSchema,
-  lastSeenAt: z5.string(),
-  provider: z5.string(),
-  providerDestinationId: z5.string(),
-  visibility: z5.literal("public")
-}).strict();
-var locationActorSummaryReportSchema = conversationStatsItemSchema.extend({ actor: actorIdentitySchema }).strict();
-var locationMetricBucketSchema = z5.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
-var locationActivityDayReportSchema = z5.object({
-  date: locationMetricBucketSchema,
-  privateConversations: z5.number(),
-  publicConversations: z5.number()
-}).strict();
-var locationDirectoryReportSchema = z5.object({
-  activityDays: z5.array(locationActivityDayReportSchema),
-  activityHours: z5.array(locationActivityDayReportSchema).optional(),
-  activitySixHours: z5.array(locationActivityDayReportSchema).optional(),
-  generatedAt: z5.string(),
-  locations: z5.array(locationSummaryReportSchema),
-  privateActivity: conversationStatsItemSchema,
-  source: z5.literal("conversation_index"),
-  windowEnd: z5.string(),
-  windowStart: z5.string()
-}).strict();
-var locationDetailReportSchema = locationSummaryReportSchema.extend({
-  activityDays: z5.array(dailyConversationActivitySchema),
-  activityHours: z5.array(dailyConversationActivitySchema).optional(),
-  activitySixHours: z5.array(dailyConversationActivitySchema).optional(),
-  actors: z5.array(locationActorSummaryReportSchema),
-  generatedAt: z5.string(),
-  recentConversations: z5.array(conversationSummaryReportSchema),
-  source: z5.literal("conversation_index"),
-  windowEnd: z5.string(),
-  windowStart: z5.string()
-}).strict();
-
-// src/api/schema/common.ts
-import { z as z6 } from "zod";
-var apiErrorSchema = z6.object({ error: z6.string().min(1) }).strict();
-
-// src/api/schema/personal-token.ts
-import { z as z7 } from "zod";
-var personalTokenMetadataSchema = z7.object({
-  id: z7.string().uuid(),
-  name: z7.string(),
-  tokenSuffix: z7.string(),
-  createdAt: z7.string().datetime(),
-  expiresAt: z7.string().datetime(),
-  lastUsedAt: z7.string().datetime().nullable()
-}).strict();
-var personalTokenListSchema = z7.object({ tokens: z7.array(personalTokenMetadataSchema) }).strict();
-var createPersonalTokenBodySchema = z7.object({ name: z7.string().trim().min(1).max(80) }).strict();
-var createdPersonalTokenSchema = personalTokenMetadataSchema.extend({ token: z7.string().startsWith("jr_pat_") }).strict();
-var personalTokenParamsSchema = z7.object({ id: z7.string().uuid() }).strict();
-var revokePersonalTokenResponseSchema = z7.object({ revoked: z7.literal(true) }).strict();
-
-// src/api/schema/workspace.ts
-import { z as z8 } from "zod";
-var workspaceRepoInputSchema = z8.object({
-  provider: z8.string(),
-  repo: z8.string()
-}).strict();
-var workspaceRepoSchema = z8.object({
-  provider: z8.string(),
-  repo: z8.string(),
-  checkoutPath: z8.string()
-}).strict();
-var workspaceSnapshotSchema = z8.object({
-  id: z8.string(),
-  generatedAt: z8.iso.datetime(),
-  buildDurationMs: z8.number().int().nonnegative(),
-  sizeBytes: z8.number().int().nonnegative().nullable()
-}).strict();
-var baselineSnapshotSchema = z8.object({
-  id: z8.string(),
-  generatedAt: z8.iso.datetime(),
-  buildDurationMs: z8.number().int().nonnegative(),
-  dependencyCount: z8.number().int().nonnegative()
-}).strict();
-var workspaceSchema = z8.object({
-  id: z8.string().uuid(),
-  name: z8.string(),
-  setupScript: z8.string(),
-  repos: z8.array(workspaceRepoSchema),
-  snapshot: workspaceSnapshotSchema.nullable()
-}).strict();
-var workspaceListSchema = z8.object({
-  baselineSnapshot: baselineSnapshotSchema.nullable(),
-  workspaces: z8.array(workspaceSchema)
-}).strict();
-var workspaceBodySchema = z8.object({
-  name: z8.string(),
-  setupScript: z8.string().optional(),
-  repos: z8.array(workspaceRepoInputSchema)
-}).strict();
-var workspaceParamsSchema = z8.object({ id: z8.string().uuid() }).strict();
-var deleteWorkspaceResponseSchema = z8.object({ deleted: z8.literal(true) }).strict();
-
-// src/api/schema/task.ts
-import { z as z9 } from "zod";
-var taskDestinationSchema = z9.object({
-  channelId: z9.string().min(1),
-  label: z9.string().min(1),
-  teamId: z9.string().min(1),
-  visibility: z9.enum(["private", "public"])
-}).strict();
-var taskRunWindowsSchema = z9.object({
-  1: z9.number().int().nonnegative(),
-  7: z9.number().int().nonnegative(),
-  30: z9.number().int().nonnegative(),
-  90: z9.number().int().nonnegative()
-}).strict();
-var taskSummaryBaseSchema = z9.object({
-  createdAt: z9.string().datetime(),
-  createdBy: z9.string().min(1),
-  createdByEmail: z9.string().trim().email().optional(),
-  destination: taskDestinationSchema,
-  id: z9.string().min(1),
-  instruction: z9.string().min(1),
-  lastConversationId: z9.string().min(1).optional(),
-  lastRunAt: z9.string().datetime().optional(),
-  ownedByViewer: z9.boolean(),
-  runs: taskRunWindowsSchema,
-  /** Short display title; falls back from instruction when unset. */
-  title: z9.string().min(1),
-  totalRuns: z9.number().int().nonnegative()
-});
-var scheduledTaskSummarySchema = taskSummaryBaseSchema.extend({
-  kind: z9.literal("scheduled"),
-  nextRunAt: z9.string().datetime().optional(),
-  schedule: z9.string().min(1),
-  status: z9.enum(["active", "blocked", "completed"])
-}).strict();
-var eventTaskSummarySchema = taskSummaryBaseSchema.extend({
-  events: z9.array(z9.string().min(1)).min(1),
-  kind: z9.literal("event"),
-  resource: z9.string().min(1),
-  source: z9.string().min(1),
-  triggerAvailable: z9.boolean()
-}).strict();
-var taskSummarySchema = z9.discriminatedUnion("kind", [
-  scheduledTaskSummarySchema,
-  eventTaskSummarySchema
-]);
-var taskMetricBucketSchema = z9.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
-var taskExecutionDaySchema = z9.object({
-  /** Linked conversation spend for executions in this bucket. */
-  costUsd: z9.number().finite().nonnegative(),
-  date: taskMetricBucketSchema,
-  event: z9.number().int().nonnegative(),
-  scheduled: z9.number().int().nonnegative()
-}).strict();
-var taskListSchema = z9.object({
-  executionDays: z9.array(taskExecutionDaySchema),
-  executionHours: z9.array(taskExecutionDaySchema).optional(),
-  executionSixHours: z9.array(taskExecutionDaySchema).optional(),
-  tasks: z9.array(taskSummarySchema),
-  truncated: z9.boolean()
-}).strict();
-var taskParamsSchema = z9.object({
-  id: z9.string().min(1),
-  kind: z9.enum(["scheduled", "event"])
-}).strict();
-var taskExecutionStatusSchema = z9.enum([
-  "blocked",
-  "completed",
-  "failed"
-]);
-var taskExecutionSchema = z9.object({
-  conversationId: z9.string().min(1).optional(),
-  /** Estimated model cost for the linked conversation, when known. */
-  costUsd: z9.number().finite().nonnegative().optional(),
-  /** Cumulative conversation runtime in milliseconds, when known. */
-  durationMs: z9.number().finite().nonnegative().optional(),
-  executedAt: z9.string().datetime(),
-  executionId: z9.string().min(1),
-  status: taskExecutionStatusSchema,
-  title: z9.string().min(1).optional(),
-  /** Cumulative conversation token total, when known. */
-  totalTokens: z9.number().int().nonnegative().optional()
-}).strict();
-var taskExecutionStatusDaySchema = z9.object({
-  blocked: z9.number().int().nonnegative(),
-  completed: z9.number().int().nonnegative(),
-  date: taskMetricBucketSchema,
-  failed: z9.number().int().nonnegative()
-}).strict();
-var taskExecutionListSchema = z9.object({
-  executionDays: z9.array(taskExecutionStatusDaySchema),
-  executionHours: z9.array(taskExecutionStatusDaySchema).optional(),
-  executionSixHours: z9.array(taskExecutionStatusDaySchema).optional(),
-  executions: z9.array(taskExecutionSchema),
-  task: taskSummarySchema,
-  truncated: z9.boolean()
-}).strict();
-var taskRunSchema = taskExecutionSchema.extend({
-  kind: z9.enum(["scheduled", "event"]),
-  taskId: z9.string().min(1),
-  taskTitle: z9.string().min(1)
-}).strict();
-var taskRunListSchema = z9.object({
-  runs: z9.array(taskRunSchema),
-  truncated: z9.boolean()
-}).strict();
-
-// src/api/schema/stats.ts
-import { z as z10 } from "zod";
-var statSchema = z10.object({
-  count: z10.number().int().nonnegative(),
-  date: z10.string(),
-  metric: z10.string().min(1),
-  name: z10.string().min(1),
-  namespace: z10.string().min(1)
-}).strict();
-var statsReportSchema = z10.object({
-  generatedAt: z10.string().datetime(),
-  stats: z10.array(statSchema),
-  windowEnd: z10.string(),
-  windowStart: z10.string()
-}).strict();
-
-export {
-  apiErrorSchema,
-  conversationParamsSchema,
-  conversationAttachmentParamsSchema,
-  conversationDetailQuerySchema,
-  conversationEventsQuerySchema,
-  conversationFeedQuerySchema,
-  archiveConversationBodySchema,
-  archiveConversationResponseSchema,
-  createConversationBodySchema,
-  createConversationMessageBodySchema,
-  acceptedConversationMessageSchema,
-  conversationPendingMessageDeliverySchema,
-  conversationPendingMessageSchema,
-  conversationPendingAuthorizationSchema,
-  conversationPendingMessagesReportSchema,
-  cancelConversationPendingMessagesBodySchema,
-  cancelConversationPendingMessagesResponseSchema,
-  conversationAuxiliaryCostsSchema,
-  conversationSummaryReportSchema,
-  conversationReportEventDataSchema,
-  conversationReportEventSchema,
-  conversationEventHistorySchema,
-  conversationDetailReportSchema,
-  conversationEventPageSchema,
-  conversationFeedSchema,
-  conversationStatsReportSchema,
-  HOUR_MS,
-  DAY_MS,
-  WINDOW_SEVEN_DAY_HOURS,
-  startOfUtcHour,
-  utcDayKey,
-  utcHourKey,
-  trailingUtcDayWindow,
-  trailingUtcHourWindow,
-  trailingUtcSixHourWindow,
-  fillUtcDays,
-  fillUtcHours,
-  fillUtcSixHours,
-  sumUtcHoursIntoSixHours,
-  codeChangeSummarySchema,
-  codeActivityDaySchema,
-  codeRepositorySummarySchema,
-  codeChangeSummaryReportSchema,
-  codeOverviewReportSchema,
-  codePersonReportSchema,
-  dailyConversationActivitySchema,
-  activityDays,
-  activityHours,
-  activitySixHours,
-  locationParamsSchema,
-  locationActivityDayReportSchema,
-  locationDirectoryReportSchema,
-  locationDetailReportSchema,
-  personParamsSchema,
-  actorDirectoryReportSchema,
-  actorProfileReportSchema,
-  personalSpendReportSchema,
-  personalTokenMetadataSchema,
-  personalTokenListSchema,
-  createPersonalTokenBodySchema,
-  createdPersonalTokenSchema,
-  personalTokenParamsSchema,
-  revokePersonalTokenResponseSchema,
-  taskRunWindowsSchema,
-  scheduledTaskSummarySchema,
-  eventTaskSummarySchema,
-  taskSummarySchema,
-  taskListSchema,
-  taskParamsSchema,
-  taskExecutionStatusSchema,
-  taskExecutionSchema,
-  taskExecutionStatusDaySchema,
-  taskExecutionListSchema,
-  taskRunSchema,
-  taskRunListSchema,
-  workspaceRepoSchema,
-  baselineSnapshotSchema,
-  workspaceSchema,
-  workspaceListSchema,
-  workspaceBodySchema,
-  workspaceParamsSchema,
-  deleteWorkspaceResponseSchema,
-  statSchema,
-  statsReportSchema
-};