@sentry/junior 0.182.0 → 0.183.0

package/dist/chunk-WVIA7V3M.js

@@ -0,0 +1,975 @@
+import {
+  usageSchema
+} from "./chunk-PDO5BLNM.js";
+import {
+  juniorDestinationKindSchema
+} from "./chunk-VFUK3X5B.js";
+
+// src/api/activity.ts
+import { z } from "zod";
+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) {
+  const items = [];
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (count - 1));
+  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+    const date = cursor.toISOString().slice(0, 10);
+    items.push(days.get(date) ?? emptyActivityDay(date));
+  }
+  return items;
+}
+
+// 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(),
+  created: z2.number().int().nonnegative(),
+  merged: z2.number().int().nonnegative(),
+  mergeRate: z2.number().min(0).max(1).optional(),
+  open: z2.number().int().nonnegative()
+}).strict();
+var codeRepositorySummarySchema = z2.object({
+  closed: z2.number().int().nonnegative(),
+  created: z2.number().int().nonnegative(),
+  id: z2.string().uuid(),
+  merged: z2.number().int().nonnegative(),
+  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({
+  changes: z2.array(codeChangeSummaryReportSchema),
+  generatedAt: z2.string(),
+  repositories: z2.array(codeRepositorySummarySchema),
+  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(),
+  sourceUrl: 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(),
+  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"),
+      failureKind: z3.enum(["agent", "delivery"])
+    }).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 conversationMetricDaySchema = z3.object({
+  cachedInputTokens: z3.number().optional(),
+  conversations: z3.number(),
+  costUsd: z3.number().optional(),
+  date: z3.string(),
+  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: z3.string(),
+  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),
+  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),
+  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 actorActivityDayReportSchema = z4.object({
+  active: z4.number(),
+  conversations: z4.number(),
+  costUsd: z4.number().optional(),
+  date: z4.string(),
+  durationMs: z4.number(),
+  failed: z4.number(),
+  tokens: z4.number().optional()
+}).strict();
+var peopleActivityDayReportSchema = z4.object({
+  activePeople: z4.number(),
+  conversations: z4.number(),
+  date: z4.string()
+}).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 identifiedActorSchema = actorIdentitySchema.extend({ email: z4.string().min(1) }).strict();
+var actorSummaryReportSchema = actorTotalsReportSchema.extend({
+  firstSeenAt: z4.string(),
+  lastSeenAt: z4.string(),
+  actor: identifiedActorSchema
+}).strict();
+var actorDirectoryReportSchema = z4.object({
+  activityDays: z4.array(peopleActivityDayReportSchema),
+  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),
+  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 locationActivityDayReportSchema = z5.object({
+  date: z5.string(),
+  privateConversations: z5.number(),
+  publicConversations: z5.number()
+}).strict();
+var locationDirectoryReportSchema = z5.object({
+  activityDays: z5.array(locationActivityDayReportSchema),
+  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),
+  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 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(),
+  runsLast7Days: z9.number().int().nonnegative(),
+  /** 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 taskExecutionDaySchema = z9.object({
+  date: z9.string().min(1),
+  event: z9.number().int().nonnegative(),
+  scheduled: z9.number().int().nonnegative()
+}).strict();
+var taskListSchema = z9.object({
+  executionDays: z9.array(taskExecutionDaySchema),
+  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(),
+  executedAt: z9.string().datetime(),
+  executionId: z9.string().min(1),
+  status: taskExecutionStatusSchema,
+  title: z9.string().min(1).optional()
+}).strict();
+var taskExecutionStatusDaySchema = z9.object({
+  blocked: z9.number().int().nonnegative(),
+  completed: z9.number().int().nonnegative(),
+  date: z9.string().min(1),
+  failed: z9.number().int().nonnegative()
+}).strict();
+var taskExecutionListSchema = z9.object({
+  executionDays: z9.array(taskExecutionStatusDaySchema),
+  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,
+  codeChangeSummarySchema,
+  codeRepositorySummarySchema,
+  codeChangeSummaryReportSchema,
+  codeOverviewReportSchema,
+  dailyConversationActivitySchema,
+  activityDays,
+  locationParamsSchema,
+  locationActivityDayReportSchema,
+  locationDirectoryReportSchema,
+  locationDetailReportSchema,
+  personParamsSchema,
+  actorDirectoryReportSchema,
+  actorProfileReportSchema,
+  personalSpendReportSchema,
+  personalTokenMetadataSchema,
+  personalTokenListSchema,
+  createPersonalTokenBodySchema,
+  createdPersonalTokenSchema,
+  personalTokenParamsSchema,
+  revokePersonalTokenResponseSchema,
+  scheduledTaskSummarySchema,
+  eventTaskSummarySchema,
+  taskSummarySchema,
+  taskListSchema,
+  taskParamsSchema,
+  taskExecutionStatusSchema,
+  taskExecutionSchema,
+  taskExecutionStatusDaySchema,
+  taskExecutionListSchema,
+  taskRunSchema,
+  taskRunListSchema,
+  workspaceRepoSchema,
+  baselineSnapshotSchema,
+  workspaceSchema,
+  workspaceListSchema,
+  workspaceBodySchema,
+  workspaceParamsSchema,
+  deleteWorkspaceResponseSchema,
+  statSchema,
+  statsReportSchema
+};