@sentry/junior 0.202.0 → 0.204.0

package/dist/schema-Rn8-XEaN.js

@@ -0,0 +1,1140 @@
+import { t as juniorDestinationKindSchema } from "./destinations-BeBiJeEM.js";
+import { a as conversationTurnFailureReasonSchema, i as conversationTurnFailureCodeSchema } from "./history-CqTuSAdI.js";
+import { t as usageSchema } from "./usage-schema-CKaDkH_j.js";
+import "./reporting-schema-DosTN__Q.js";
+import { z } from "zod";
+import { codeChangeStateSchema, conversationAnnotationInputSchema, conversationEventPresentationSchema, conversationSidebarAnnotationSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+//#region src/api/schema/common.ts
+/** Stable error body returned by Junior-owned REST endpoints. */
+const apiErrorSchema = z.object({ error: z.string().min(1) }).strict();
+//#endregion
+//#region src/api/schema/conversation.ts
+const conversationReportStatusSchema = z.enum([
+	"active",
+	"completed",
+	"failed"
+]);
+const conversationSurfaceSchema = z.enum([
+	"api",
+	"internal",
+	"scheduler",
+	"slack"
+]);
+const conversationUsageSchema = usageSchema;
+const conversationParamsSchema = z.object({ conversationId: z.string().min(1) }).strict();
+const conversationAttachmentParamsSchema = z.object({
+	attachmentId: z.string().min(1),
+	conversationId: z.string().min(1)
+}).strict();
+const conversationDetailQuerySchema = z.object({ limit: z.coerce.number().int().min(1).max(1e3).default(500) }).strict();
+const conversationEventsQuerySchema = z.object({
+	before: z.string().min(1),
+	limit: z.coerce.number().int().min(1).max(1e3).default(500)
+}).strict();
+const conversationFeedQuerySchema = z.object({
+	actorEmail: z.string().trim().email().transform((value) => value.toLowerCase()).optional(),
+	q: z.string().trim().max(200).optional(),
+	status: z.enum(["active", "archived"]).default("active")
+}).strict();
+const archiveConversationBodySchema = z.object({
+	archived: z.boolean(),
+	lastSeenAt: z.string().datetime()
+}).strict();
+const archiveConversationResponseSchema = z.object({ archivedAt: z.string().datetime().nullable() }).strict();
+const createConversationBodySchema = z.object({
+	idempotencyKey: z.string().trim().min(1).max(200),
+	message: z.string().trim().min(1).max(32e3),
+	/** New roots default public. Private roots stay participant-only. */
+	visibility: z.enum(["private", "public"]).optional()
+}).strict();
+const createConversationMessageBodySchema = z.object({
+	idempotencyKey: z.string().trim().min(1).max(200),
+	message: z.string().trim().min(1).max(32e3)
+}).strict();
+const acceptedConversationMessageSchema = z.object({
+	conversationId: z.string().min(1),
+	messageId: z.string().min(1),
+	status: z.enum(["accepted", "duplicate"])
+}).strict();
+const actorIdentitySchema = z.object({
+	email: z.string().optional(),
+	fullName: z.string().optional(),
+	slackUserId: z.string().optional(),
+	slackUserName: z.string().optional()
+}).strict();
+/** Mailbox delivery mode for one accepted inbound message. */
+const conversationPendingMessageDeliverySchema = z.enum(["defer", "interrupt"]);
+/** One accepted mailbox message that has not reached durable history yet. */
+const conversationPendingMessageSchema = z.object({
+	actorIdentity: actorIdentitySchema.optional(),
+	createdAt: z.string().datetime(),
+	delivery: conversationPendingMessageDeliverySchema,
+	inboundMessageId: z.string().min(1),
+	messageId: z.string().min(1),
+	receivedAt: z.string().datetime(),
+	role: z.literal("user"),
+	source: z.enum(["slack", "web"]),
+	text: z.string().optional(),
+	redacted: z.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"
+	});
+});
+/** Participant-only authorization prompt for a parked web turn. */
+const conversationPendingAuthorizationSchema = z.object({
+	authorizationUrl: z.string().url(),
+	completionText: z.string().min(1),
+	label: z.string().min(1)
+}).strict();
+/** Bounded mailbox snapshot for one conversation transcript. */
+const conversationPendingMessagesReportSchema = z.object({
+	authorization: conversationPendingAuthorizationSchema.optional(),
+	conversationId: z.string().min(1),
+	generatedAt: z.string().datetime(),
+	messages: z.array(conversationPendingMessageSchema)
+}).strict();
+/** Optional filters for cancelling accepted mailbox rows. */
+const cancelConversationPendingMessagesBodySchema = z.object({
+	inboundMessageIds: z.array(z.string().min(1)).min(1).optional(),
+	receivedBefore: z.string().datetime().optional()
+}).strict();
+/** Result of cancelling accepted human-facing mailbox rows. */
+const cancelConversationPendingMessagesResponseSchema = z.object({
+	cancelledCount: z.number().int().nonnegative(),
+	cancelledInboundMessageIds: z.array(z.string().min(1)),
+	conversationId: z.string().min(1)
+}).strict();
+const conversationAuxiliaryCostsSchema = z.object({
+	costUsd: z.number().finite().nonnegative(),
+	operations: z.array(z.object({
+		costUsd: z.number().finite().nonnegative(),
+		events: z.number().int().positive(),
+		name: z.string().min(1),
+		namespace: z.string().min(1)
+	}).strict()).min(1)
+}).strict();
+/** Optional reverse link from a task-triggered conversation back to its task. */
+const conversationSourceTaskSchema = z.object({
+	id: z.string().min(1).optional(),
+	kind: z.enum(["scheduled", "event"]),
+	label: z.string().min(1).optional(),
+	title: z.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"
+	});
+});
+const conversationAnnotationReportSchema = conversationAnnotationInputSchema.and(z.object({
+	plugin: z.string().min(1),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime()
+}));
+const conversationActivityPreviewSchema = z.object({
+	createdAt: z.string().datetime(),
+	role: z.enum(["assistant", "user"]),
+	text: z.string().min(1)
+}).strict();
+const conversationSummaryReportSchema = z.object({
+	displayTitle: z.string(),
+	activityPreview: conversationActivityPreviewSchema.optional(),
+	cumulativeDurationMs: z.number(),
+	cumulativeUsage: conversationUsageSchema.optional(),
+	auxiliaryCosts: conversationAuxiliaryCostsSchema.optional(),
+	conversationId: z.string(),
+	isParticipant: z.boolean(),
+	visibility: z.enum(["private", "public"]).optional(),
+	status: conversationReportStatusSchema,
+	startedAt: z.string(),
+	lastSeenAt: z.string(),
+	lastProgressAt: z.string(),
+	surface: conversationSurfaceSchema,
+	actorIdentity: actorIdentitySchema.optional(),
+	archivedAt: z.string().datetime().nullable().optional(),
+	channel: z.string().optional(),
+	channelName: z.string().optional(),
+	channelNameRedacted: z.boolean().optional(),
+	locationId: z.string().optional(),
+	sentryTraceUrl: z.string().optional(),
+	locationUrl: z.string().url().optional(),
+	traceId: z.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: z.array(conversationAnnotationReportSchema).optional(),
+	/** Plugin-selected annotations for the compact conversation row. */
+	sidebarAnnotations: z.array(conversationSidebarAnnotationSchema).optional(),
+	assignedWork: z.boolean().optional(),
+	finishedWorkAt: z.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: z.boolean().optional(),
+	unfinishedWork: z.boolean().optional()
+}).strict();
+const conversationReportMessageEventDataSchema = z.object({
+	type: z.literal("message"),
+	messageId: z.string().min(1),
+	role: z.enum([
+		"assistant",
+		"system",
+		"user"
+	]),
+	source: z.enum(["slack", "web"]).optional(),
+	actorIdentity: actorIdentitySchema.optional(),
+	eventType: z.string().min(1).optional(),
+	explicitMention: z.boolean().optional(),
+	trustedSummary: z.string().min(1).optional(),
+	text: z.string().optional(),
+	redacted: z.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"
+	});
+});
+const conversationReportMessageHandledEventDataSchema = z.object({
+	type: z.literal("message_handled"),
+	messageId: z.string().min(1)
+}).strict();
+const conversationReportToolCallSchema = z.object({
+	toolCallId: z.string().min(1),
+	name: z.string().min(1),
+	status: z.enum([
+		"running",
+		"completed",
+		"error"
+	]),
+	startedAt: z.string().datetime().optional(),
+	startedSeq: z.number().int().nonnegative().optional(),
+	input: z.unknown().optional(),
+	output: z.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"
+	});
+});
+const conversationReportReasoningPartSchema = z.object({
+	type: z.literal("reasoning"),
+	text: z.string().min(1).optional(),
+	redacted: z.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"
+	});
+});
+const conversationReportAssistantToolCallPartSchema = z.object({
+	type: z.literal("tool_call"),
+	toolCallId: z.string().min(1)
+}).strict();
+const conversationReportAssistantMetadataSchema = z.object({ parts: z.array(z.discriminatedUnion("type", [conversationReportReasoningPartSchema, conversationReportAssistantToolCallPartSchema])).min(1) }).strict();
+const conversationReportToolCallsEventDataSchema = z.object({
+	type: z.literal("tool_calls"),
+	calls: z.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"
+	});
+});
+const conversationReportAssistantMessageEventDataSchema = z.object({
+	type: z.literal("assistant_message"),
+	parts: z.array(conversationReportReasoningPartSchema).min(1)
+}).strict();
+const conversationReportTurnLifecycleEventDataSchema = z.discriminatedUnion("state", [
+	z.object({
+		type: z.literal("turn_lifecycle"),
+		turnId: z.string().min(1),
+		state: z.enum(["succeeded", "no_reply"])
+	}).strict(),
+	z.object({
+		type: z.literal("turn_lifecycle"),
+		turnId: z.string().min(1),
+		state: z.literal("started"),
+		inputMessageIds: z.array(z.string().min(1)).min(1).optional()
+	}).strict(),
+	z.object({
+		type: z.literal("turn_lifecycle"),
+		turnId: z.string().min(1),
+		state: z.literal("failed"),
+		failureCode: conversationTurnFailureCodeSchema,
+		failureReason: conversationTurnFailureReasonSchema.optional(),
+		eventId: z.string().regex(/^[a-f0-9]{32}$/i).optional(),
+		sentryEventUrl: z.string().url().optional()
+	}).strict()
+]);
+const conversationReportTurnRoutedEventDataSchema = z.object({
+	type: z.literal("turn_routed"),
+	turnId: z.string().min(1),
+	modelProfile: z.string().min(1),
+	modelId: z.string().min(1),
+	costUsd: z.number().finite().nonnegative().optional(),
+	reasoningLevel: z.string().min(1),
+	confidence: z.number().min(0).max(1).optional(),
+	source: z.enum([
+		"configured",
+		"inherited",
+		"router"
+	])
+}).strict();
+const conversationReportGuardianActionReviewedEventDataSchema = z.object({
+	type: z.literal("guardian_action_reviewed"),
+	turnId: z.string().min(1),
+	toolCallId: z.string().min(1),
+	toolName: z.string().min(1),
+	decision: z.enum([
+		"allow",
+		"ask",
+		"deny"
+	]),
+	riskLevel: z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	]),
+	userAuthorization: z.enum([
+		"high",
+		"medium",
+		"low",
+		"unknown"
+	])
+}).strict();
+const conversationReportTurnContextEventDataSchema = z.object({
+	type: z.literal("turn_context"),
+	turnId: z.string().min(1),
+	pluginName: z.string().min(1),
+	kind: z.string().min(1),
+	version: z.number().int().positive(),
+	content: z.record(z.string(), z.unknown())
+}).strict();
+const conversationReportStructuredEventDataSchema = z.object({
+	type: z.literal("structured_event"),
+	namespace: z.string().min(1),
+	name: z.string().min(1),
+	version: z.number().int().positive(),
+	turnId: z.string().min(1).optional(),
+	presentation: conversationEventPresentationSchema
+}).strict();
+/** Public attachment metadata on conversation reports and transcript media. */
+const conversationReportDeliveredAttachmentSchema = z.object({
+	id: z.string().min(1),
+	filename: z.string().min(1),
+	contentType: z.string().min(1),
+	bytes: z.number().int().nonnegative()
+}).strict();
+const conversationReportAttachmentsDeliveredEventDataSchema = z.object({
+	type: z.literal("attachments_delivered"),
+	attachments: z.array(conversationReportDeliveredAttachmentSchema).min(1)
+}).strict();
+const conversationReportCompactionEventDataSchema = z.object({
+	type: z.literal("compaction"),
+	modelProfile: z.string().min(1).optional(),
+	modelId: z.string().min(1).optional(),
+	summary: z.string().min(1).optional(),
+	details: z.object({
+		reason: z.literal("capacity"),
+		estimatedInputTokens: z.number().int().nonnegative(),
+		replacementInputTokens: z.number().int().nonnegative().optional(),
+		triggerTokens: z.number().int().nonnegative(),
+		inputLimitTokens: z.number().int().positive(),
+		inputMessageCount: z.number().int().nonnegative(),
+		retainedMessageCount: z.number().int().nonnegative(),
+		summaryChars: z.number().int().nonnegative()
+	}).strict().optional()
+}).strict();
+const conversationReportHandoffEventDataSchema = z.object({
+	type: z.literal("handoff"),
+	modelProfile: z.string().min(1),
+	modelId: z.string().min(1),
+	reasoningLevel: z.string().min(1).optional(),
+	triggeringToolCallId: z.string().min(1).optional(),
+	summary: z.string().min(1).optional()
+}).strict();
+const conversationReportSubagentEventDataSchema = z.object({
+	type: z.literal("subagent"),
+	startedSeq: z.number().int().nonnegative(),
+	startedAt: z.string().datetime(),
+	childConversationId: z.string().min(1),
+	subagentKind: z.string().min(1),
+	parentToolCallId: z.string().min(1).optional(),
+	status: z.enum([
+		"running",
+		"completed",
+		"error",
+		"aborted"
+	])
+}).strict();
+/** Privacy-safe event variants owned by the conversation reporting API. */
+const conversationReportEventDataSchema = z.discriminatedUnion("type", [
+	conversationReportMessageEventDataSchema,
+	conversationReportMessageHandledEventDataSchema,
+	conversationReportAssistantMessageEventDataSchema,
+	conversationReportToolCallsEventDataSchema,
+	conversationReportTurnLifecycleEventDataSchema,
+	conversationReportTurnContextEventDataSchema,
+	conversationReportStructuredEventDataSchema,
+	conversationReportAttachmentsDeliveredEventDataSchema,
+	conversationReportTurnRoutedEventDataSchema,
+	conversationReportGuardianActionReviewedEventDataSchema,
+	conversationReportCompactionEventDataSchema,
+	conversationReportHandoffEventDataSchema,
+	conversationReportSubagentEventDataSchema
+]);
+/** One ordered, privacy-safe canonical event projected for API consumers. */
+const conversationReportEventSchema = z.object({
+	seq: z.number().int().nonnegative(),
+	createdAt: z.string().datetime(),
+	data: conversationReportEventDataSchema
+}).strict();
+/** Availability of the canonical event history attached to a detail report. */
+const conversationEventHistorySchema = z.discriminatedUnion("status", [
+	z.object({ status: z.literal("available") }).strict(),
+	z.object({
+		status: z.literal("redacted"),
+		reason: z.literal("non_public_conversation")
+	}).strict(),
+	z.object({
+		status: z.literal("expired"),
+		expiredAt: z.string().datetime()
+	}).strict()
+]);
+const conversationModelUsageSchema = z.object({
+	modelId: z.string(),
+	usage: conversationUsageSchema
+}).strict();
+/** Enforce event ordering and history visibility across paginated wire payloads. */
+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"
+		});
+	}
+}
+const conversationDetailReportSchema = conversationSummaryReportSchema.extend({
+	modelUsage: z.array(conversationModelUsageSchema).optional(),
+	events: z.array(conversationReportEventSchema),
+	eventHistory: conversationEventHistorySchema,
+	previousCursor: z.string().min(1).optional(),
+	generatedAt: z.string(),
+	sentryConversationUrl: z.string().optional(),
+	sourceTask: conversationSourceTaskSchema.optional()
+}).strict().superRefine(validateConversationEvents);
+const conversationEventPageSchema = z.object({
+	events: z.array(conversationReportEventSchema),
+	eventHistory: conversationEventHistorySchema,
+	previousCursor: z.string().min(1).optional(),
+	generatedAt: z.string()
+}).strict().superRefine(validateConversationEvents);
+const conversationFeedSchema = z.object({
+	conversations: z.array(conversationSummaryReportSchema),
+	source: z.literal("conversation_index"),
+	generatedAt: z.string()
+}).strict();
+const conversationStatsItemSchema = z.object({
+	active: z.number(),
+	conversations: z.number(),
+	durationMs: z.number(),
+	failed: z.number(),
+	label: z.string(),
+	costUsd: z.number().optional(),
+	tokens: z.number().optional()
+}).strict();
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const conversationMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const conversationMetricDaySchema = z.object({
+	cachedInputTokens: z.number().optional(),
+	conversations: z.number(),
+	costUsd: z.number().optional(),
+	date: conversationMetricBucketSchema,
+	durationMs: z.number(),
+	inputTokens: z.number().optional(),
+	tokens: z.number().optional()
+}).strict();
+const guardianMetricDaySchema = z.object({
+	allow: z.number(),
+	ask: z.number(),
+	costUsd: z.number().optional(),
+	date: conversationMetricBucketSchema,
+	deny: z.number(),
+	requests: z.number()
+}).strict();
+const guardianStatsSchema = z.object({
+	allow: z.number(),
+	ask: z.number(),
+	costUsd: z.number().optional(),
+	deny: z.number(),
+	metricDays: z.array(guardianMetricDaySchema),
+	metricHours: z.array(guardianMetricDaySchema).optional(),
+	metricSixHours: z.array(guardianMetricDaySchema).optional(),
+	requests: z.number()
+}).strict();
+const conversationStatsReportSchema = z.object({
+	active: z.number(),
+	cachedInputTokens: z.number().optional(),
+	conversations: z.number(),
+	durationMs: z.number(),
+	failed: z.number(),
+	generatedAt: z.string(),
+	guardian: guardianStatsSchema,
+	metricDays: z.array(conversationMetricDaySchema),
+	metricHours: z.array(conversationMetricDaySchema).optional(),
+	metricSixHours: z.array(conversationMetricDaySchema).optional(),
+	locations: z.array(conversationStatsItemSchema),
+	actors: z.array(conversationStatsItemSchema),
+	source: z.literal("conversation_index"),
+	costUsd: z.number().optional(),
+	inputTokens: z.number().optional(),
+	tokens: z.number().optional(),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/reporting-window.ts
+/** Shared UTC day/hour/six-hour windows for dashboard activity series. */
+const HOUR_MS = 36e5;
+const SIX_HOUR_MS = 6 * HOUR_MS;
+const DAY_MS = 24 * HOUR_MS;
+/** Start of the UTC calendar day containing `valueMs`. */
+function startOfUtcDay(valueMs) {
+	const date = new Date(valueMs);
+	date.setUTCHours(0, 0, 0, 0);
+	return date;
+}
+/** Start of the UTC hour containing `valueMs`. */
+function startOfUtcHour(valueMs) {
+	const date = new Date(valueMs);
+	date.setUTCMinutes(0, 0, 0);
+	return date;
+}
+/** Start of the UTC 6-hour bucket containing `valueMs` (00/06/12/18). */
+function startOfUtcSixHour(valueMs) {
+	const date = startOfUtcHour(valueMs);
+	date.setUTCHours(Math.floor(date.getUTCHours() / 6) * 6, 0, 0, 0);
+	return date;
+}
+/** UTC day key `YYYY-MM-DD`. */
+function utcDayKey(value) {
+	return (typeof value === "number" ? new Date(value) : value).toISOString().slice(0, 10);
+}
+/** UTC hour key `YYYY-MM-DDTHH`. */
+function utcHourKey(value) {
+	return (typeof value === "number" ? new Date(value) : value).toISOString().slice(0, 13);
+}
+/** UTC 6-hour bucket key `YYYY-MM-DDTHH` at 00/06/12/18. */
+function utcSixHourKey(value) {
+	return utcHourKey(startOfUtcSixHour(typeof value === "number" ? value : value.getTime()));
+}
+/** Inclusive trailing UTC day window ending on today's UTC day. */
+function trailingUtcDayWindow(nowMs, dayCount) {
+	const end = startOfUtcDay(nowMs);
+	const start = new Date(end);
+	start.setUTCDate(start.getUTCDate() - (dayCount - 1));
+	return {
+		end,
+		start
+	};
+}
+/** Inclusive trailing UTC hour window ending on the current UTC hour. */
+function trailingUtcHourWindow(nowMs, hourCount = 24) {
+	const end = startOfUtcHour(nowMs);
+	return {
+		end,
+		start: /* @__PURE__ */ new Date(end.getTime() - (hourCount - 1) * HOUR_MS)
+	};
+}
+/** Inclusive trailing UTC 6-hour window ending on the current 6h bucket. */
+function trailingUtcSixHourWindow(nowMs, bucketCount = 28) {
+	const end = startOfUtcSixHour(nowMs);
+	return {
+		end,
+		start: /* @__PURE__ */ new Date(end.getTime() - (bucketCount - 1) * SIX_HOUR_MS)
+	};
+}
+/** Fill a fixed UTC day window from a sparse map. */
+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;
+}
+/** Fill a fixed UTC hour window from a sparse map. */
+function fillUtcHours(args) {
+	const hourCount = args.count ?? 24;
+	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;
+}
+/** Fill a fixed UTC 6-hour window from a map of known rows. */
+function fillUtcSixHours(args) {
+	const bucketCount = args.count ?? 28;
+	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;
+}
+/**
+* Sum hour rows into trailing 6-hour buckets.
+* Adds number fields. Keeps other fields from the first row in the bucket.
+* Sets `date` to the 6-hour bucket key.
+*/
+function sumUtcHoursIntoSixHours(args) {
+	const bucketCount = args.count ?? 28;
+	const bySix = /* @__PURE__ */ new Map();
+	for (const hour of args.hours) {
+		const key = utcSixHourKey(Date.parse(`${hour.date}:00:00.000Z`));
+		const next = {
+			...bySix.get(key) ?? args.empty(key),
+			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
+	});
+}
+//#endregion
+//#region src/api/schema/code.ts
+const codeChangeSummarySchema = z.object({
+	closed: z.number().int().nonnegative(),
+	costUsd: z.number().nonnegative().optional(),
+	created: z.number().int().nonnegative(),
+	medianCostUsd: z.number().nonnegative().optional(),
+	medianMergeTimeMs: z.number().nonnegative().optional(),
+	merged: z.number().int().nonnegative(),
+	mergeRate: z.number().min(0).max(1).optional(),
+	open: z.number().int().nonnegative()
+}).strict();
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const codeMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const codeActivityDaySchema = z.object({
+	closed: z.number().int().nonnegative(),
+	created: z.number().int().nonnegative(),
+	date: codeMetricBucketSchema,
+	merged: z.number().int().nonnegative()
+}).strict();
+const codeRepositorySummarySchema = z.object({
+	closed: z.number().int().nonnegative(),
+	created: z.number().int().nonnegative(),
+	id: z.string().uuid(),
+	medianCostUsd: z.number().nonnegative().optional(),
+	merged: z.number().int().nonnegative(),
+	mergeRate: z.number().min(0).max(1).optional(),
+	name: z.string().min(1),
+	open: z.number().int().nonnegative(),
+	provider: z.string().min(1),
+	url: z.string().url().optional()
+}).strict();
+const codeChangeSummaryReportSchema = z.object({
+	closedAt: z.string().optional(),
+	id: z.string().uuid(),
+	mergedAt: z.string().optional(),
+	number: z.number().int().positive(),
+	openedAt: z.string(),
+	provider: z.string().min(1),
+	repository: z.string().min(1),
+	state: codeChangeStateSchema,
+	title: z.string().optional(),
+	url: z.string().url().optional()
+}).strict();
+const codeOverviewReportSchema = z.object({
+	activityDays: z.array(codeActivityDaySchema),
+	activityHours: z.array(codeActivityDaySchema).optional(),
+	activitySixHours: z.array(codeActivityDaySchema).optional(),
+	changes: z.array(codeChangeSummaryReportSchema),
+	generatedAt: z.string(),
+	repositories: z.array(codeRepositorySummarySchema),
+	summary: codeChangeSummarySchema,
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+/** Person-scoped code activity for one People profile. */
+const codePersonReportSchema = z.object({
+	activityDays: z.array(codeActivityDaySchema),
+	activityHours: z.array(codeActivityDaySchema).optional(),
+	activitySixHours: z.array(codeActivityDaySchema).optional(),
+	generatedAt: z.string(),
+	summary: codeChangeSummarySchema,
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/activity.ts
+const dailyConversationActivitySchema = z.object({
+	active: z.number(),
+	conversations: z.number(),
+	date: z.string(),
+	durationMs: z.number(),
+	failed: z.number(),
+	tokens: z.number().optional()
+}).strict();
+/** Build a zeroed day for conversation activity projections. */
+function emptyActivityDay(date) {
+	return {
+		active: 0,
+		conversations: 0,
+		date,
+		durationMs: 0,
+		failed: 0
+	};
+}
+/** Fill a fixed UTC day window from sparse conversation activity. */
+function activityDays(days, nowMs, count) {
+	return fillUtcDays({
+		count,
+		empty: emptyActivityDay,
+		nowMs,
+		rows: days
+	});
+}
+/**
+* Fill the trailing 7-day UTC hour window from known hour rows.
+* 24h charts use the last 24 points. 7d charts sum hours into 6-hour buckets.
+*/
+function activityHours(hours, nowMs) {
+	return fillUtcHours({
+		count: 168,
+		empty: emptyActivityDay,
+		nowMs,
+		rows: hours
+	});
+}
+/**
+* Fill trailing 6-hour buckets from hour keys or hour rows.
+* Hour keys must be summed into 6-hour keys first.
+*/
+function activitySixHours(hours, nowMs) {
+	return sumUtcHoursIntoSixHours({
+		empty: emptyActivityDay,
+		hours: hours instanceof Map ? activityHours(hours, nowMs) : [...hours],
+		nowMs
+	});
+}
+//#endregion
+//#region src/api/schema/location.ts
+const locationParamsSchema = z.object({ locationId: z.string().min(1) }).strict();
+const locationSummaryReportSchema = conversationStatsItemSchema.extend({
+	id: z.string(),
+	firstSeenAt: z.string(),
+	kind: juniorDestinationKindSchema,
+	lastSeenAt: z.string(),
+	provider: z.string(),
+	providerDestinationId: z.string(),
+	visibility: z.literal("public")
+}).strict();
+const locationActorSummaryReportSchema = conversationStatsItemSchema.extend({ actor: actorIdentitySchema }).strict();
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const locationMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const locationActivityDayReportSchema = z.object({
+	date: locationMetricBucketSchema,
+	privateConversations: z.number(),
+	publicConversations: z.number()
+}).strict();
+const locationDirectoryReportSchema = z.object({
+	activityDays: z.array(locationActivityDayReportSchema),
+	activityHours: z.array(locationActivityDayReportSchema).optional(),
+	activitySixHours: z.array(locationActivityDayReportSchema).optional(),
+	generatedAt: z.string(),
+	locations: z.array(locationSummaryReportSchema),
+	privateActivity: conversationStatsItemSchema,
+	source: z.literal("conversation_index"),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+const locationDetailReportSchema = locationSummaryReportSchema.extend({
+	activityDays: z.array(dailyConversationActivitySchema),
+	activityHours: z.array(dailyConversationActivitySchema).optional(),
+	activitySixHours: z.array(dailyConversationActivitySchema).optional(),
+	actors: z.array(locationActorSummaryReportSchema),
+	generatedAt: z.string(),
+	recentConversations: z.array(conversationSummaryReportSchema),
+	source: z.literal("conversation_index"),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/schema/person.ts
+const personParamsSchema = z.object({ email: z.string().trim().min(1) }).strict();
+const peopleConversationStatsItemSchema = conversationStatsItemSchema.omit({ costUsd: true });
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const peopleMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const actorActivityDayReportSchema = z.object({
+	active: z.number(),
+	conversations: z.number(),
+	costUsd: z.number().optional(),
+	date: peopleMetricBucketSchema,
+	durationMs: z.number(),
+	failed: z.number(),
+	tokens: z.number().optional()
+}).strict();
+const peopleActivityDayReportSchema = z.object({
+	activePeople: z.number(),
+	conversations: z.number(),
+	date: peopleMetricBucketSchema
+}).strict();
+const actorTotalsReportSchema = z.object({
+	active: z.number(),
+	activeDays: z.number(),
+	conversations: z.number(),
+	durationMs: z.number(),
+	failed: z.number(),
+	tokens: z.number().optional()
+}).strict();
+/** Spend and activity for one people-directory range, plus the prior period's spend. */
+const actorWindowMetricsSchema = z.object({
+	conversations: z.number().int().nonnegative(),
+	costUsd: z.number().finite().nonnegative(),
+	durationMs: z.number().finite().nonnegative(),
+	priorCostUsd: z.number().finite().nonnegative()
+}).strict();
+/** People-directory ranges that match the dashboard range control. */
+const actorDirectoryWindowsSchema = z.object({
+	1: actorWindowMetricsSchema,
+	7: actorWindowMetricsSchema,
+	30: actorWindowMetricsSchema,
+	90: actorWindowMetricsSchema
+}).strict();
+const identifiedActorSchema = actorIdentitySchema.extend({ email: z.string().min(1) }).strict();
+const actorSummaryReportSchema = actorTotalsReportSchema.extend({
+	firstSeenAt: z.string(),
+	lastSeenAt: z.string(),
+	actor: identifiedActorSchema,
+	windows: actorDirectoryWindowsSchema
+}).strict();
+const actorDirectoryReportSchema = z.object({
+	activityDays: z.array(peopleActivityDayReportSchema),
+	activityHours: z.array(peopleActivityDayReportSchema).optional(),
+	activitySixHours: z.array(peopleActivityDayReportSchema).optional(),
+	generatedAt: z.string(),
+	people: z.array(actorSummaryReportSchema),
+	source: z.literal("conversation_index"),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+const actorProfileReportSchema = z.object({
+	activityDays: z.array(actorActivityDayReportSchema),
+	activityHours: z.array(actorActivityDayReportSchema).optional(),
+	activitySixHours: z.array(actorActivityDayReportSchema).optional(),
+	generatedAt: z.string(),
+	locations: z.array(peopleConversationStatsItemSchema),
+	recentConversations: z.array(conversationSummaryReportSchema),
+	actor: identifiedActorSchema,
+	source: z.literal("conversation_index"),
+	surfaces: z.array(peopleConversationStatsItemSchema),
+	totals: actorTotalsReportSchema,
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+const personalSpendReportSchema = z.object({
+	generatedAt: z.string(),
+	sevenDaysUsd: z.number().finite().nonnegative(),
+	source: z.literal("conversation_index"),
+	thirtyDaysUsd: z.number().finite().nonnegative(),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/schema/personal-token.ts
+const personalTokenMetadataSchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	tokenSuffix: z.string(),
+	createdAt: z.string().datetime(),
+	expiresAt: z.string().datetime(),
+	lastUsedAt: z.string().datetime().nullable()
+}).strict();
+const personalTokenListSchema = z.object({ tokens: z.array(personalTokenMetadataSchema) }).strict();
+const createPersonalTokenBodySchema = z.object({ name: z.string().trim().min(1).max(80) }).strict();
+const createdPersonalTokenSchema = personalTokenMetadataSchema.extend({ token: z.string().startsWith("jr_pat_") }).strict();
+const personalTokenParamsSchema = z.object({ id: z.string().uuid() }).strict();
+const revokePersonalTokenResponseSchema = z.object({ revoked: z.literal(true) }).strict();
+//#endregion
+//#region src/api/schema/task.ts
+const taskDestinationSchema = z.object({
+	channelId: z.string().min(1),
+	label: z.string().min(1),
+	teamId: z.string().min(1),
+	visibility: z.enum(["private", "public"])
+}).strict();
+/** Task run counts for the dashboard range control (24h/7d/30d/90d). */
+const taskRunWindowsSchema = z.object({
+	1: z.number().int().nonnegative(),
+	7: z.number().int().nonnegative(),
+	30: z.number().int().nonnegative(),
+	90: z.number().int().nonnegative()
+}).strict();
+const taskSummaryBaseSchema = z.object({
+	createdAt: z.string().datetime(),
+	createdBy: z.string().min(1),
+	createdByEmail: z.string().trim().email().optional(),
+	destination: taskDestinationSchema,
+	id: z.string().min(1),
+	instruction: z.string().min(1),
+	lastConversationId: z.string().min(1).optional(),
+	lastRunAt: z.string().datetime().optional(),
+	ownedByViewer: z.boolean(),
+	runs: taskRunWindowsSchema,
+	outcomes: z.array(taskOutcomeSchema).max(5),
+	/** Short display title; falls back from instruction when unset. */
+	title: z.string().min(1),
+	totalRuns: z.number().int().nonnegative()
+});
+const scheduledTaskSummarySchema = taskSummaryBaseSchema.extend({
+	kind: z.literal("scheduled"),
+	nextRunAt: z.string().datetime().optional(),
+	schedule: z.string().min(1),
+	status: z.enum([
+		"active",
+		"blocked",
+		"completed"
+	])
+}).strict();
+const eventTaskSummarySchema = taskSummaryBaseSchema.extend({
+	events: z.array(z.string().min(1)).min(1),
+	kind: z.literal("event"),
+	resource: z.string().min(1),
+	source: z.string().min(1),
+	triggerAvailable: z.boolean()
+}).strict();
+const taskSummarySchema = z.discriminatedUnion("kind", [scheduledTaskSummarySchema, eventTaskSummarySchema]);
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) execution bucket key. */
+const taskMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+/** One UTC day/hour of completed task executions stacked by task type. */
+const taskExecutionDaySchema = z.object({
+	/** Linked conversation spend for executions in this bucket. */
+	costUsd: z.number().finite().nonnegative(),
+	date: taskMetricBucketSchema,
+	event: z.number().int().nonnegative(),
+	scheduled: z.number().int().nonnegative()
+}).strict();
+const taskListQuerySchema = z.object({ q: z.string().trim().max(200).optional() }).strict();
+const taskListSchema = z.object({
+	executionDays: z.array(taskExecutionDaySchema),
+	executionHours: z.array(taskExecutionDaySchema).optional(),
+	executionSixHours: z.array(taskExecutionDaySchema).optional(),
+	tasks: z.array(taskSummarySchema),
+	truncated: z.boolean()
+}).strict();
+const taskParamsSchema = z.object({
+	id: z.string().min(1),
+	kind: z.enum(["scheduled", "event"])
+}).strict();
+const taskExecutionStatusSchema = z.enum([
+	"blocked",
+	"completed",
+	"failed"
+]);
+const taskExecutionSchema = z.object({
+	conversationId: z.string().min(1).optional(),
+	/** Estimated model cost for the linked conversation, when known. */
+	costUsd: z.number().finite().nonnegative().optional(),
+	/** Cumulative conversation runtime in milliseconds, when known. */
+	durationMs: z.number().finite().nonnegative().optional(),
+	executedAt: z.string().datetime(),
+	executionId: z.string().min(1),
+	status: taskExecutionStatusSchema,
+	title: z.string().min(1).optional(),
+	/** Cumulative conversation token total, when known. */
+	totalTokens: z.number().int().nonnegative().optional()
+}).strict();
+/** One UTC day/hour of terminal executions for a single task, stacked by status. */
+const taskExecutionStatusDaySchema = z.object({
+	blocked: z.number().int().nonnegative(),
+	completed: z.number().int().nonnegative(),
+	date: taskMetricBucketSchema,
+	failed: z.number().int().nonnegative()
+}).strict();
+const taskExecutionListSchema = z.object({
+	executionDays: z.array(taskExecutionStatusDaySchema),
+	executionHours: z.array(taskExecutionStatusDaySchema).optional(),
+	executionSixHours: z.array(taskExecutionStatusDaySchema).optional(),
+	executions: z.array(taskExecutionSchema),
+	task: taskSummarySchema,
+	truncated: z.boolean()
+}).strict();
+const taskRunSchema = taskExecutionSchema.extend({
+	kind: z.enum(["scheduled", "event"]),
+	taskId: z.string().min(1),
+	taskTitle: z.string().min(1)
+}).strict();
+const taskRunListSchema = z.object({
+	runs: z.array(taskRunSchema),
+	truncated: z.boolean()
+}).strict();
+//#endregion
+//#region src/api/schema/workspace.ts
+const workspaceRepoInputSchema = z.object({
+	provider: z.string(),
+	repo: z.string()
+}).strict();
+const workspaceRepoSchema = z.object({
+	provider: z.string(),
+	repo: z.string(),
+	checkoutPath: z.string()
+}).strict();
+const workspaceSnapshotSchema = z.object({
+	id: z.string(),
+	generatedAt: z.iso.datetime(),
+	buildDurationMs: z.number().int().nonnegative(),
+	sizeBytes: z.number().int().nonnegative().nullable()
+}).strict();
+/** Install-wide baseline Sandbox snapshot used when no Workspace recipe is selected. */
+const baselineSnapshotSchema = z.object({
+	id: z.string(),
+	generatedAt: z.iso.datetime(),
+	buildDurationMs: z.number().int().nonnegative(),
+	dependencyCount: z.number().int().nonnegative()
+}).strict();
+const workspaceSchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	setupScript: z.string(),
+	repos: z.array(workspaceRepoSchema),
+	snapshot: workspaceSnapshotSchema.nullable()
+}).strict();
+const workspaceListSchema = z.object({
+	baselineSnapshot: baselineSnapshotSchema.nullable(),
+	workspaces: z.array(workspaceSchema)
+}).strict();
+const workspaceBodySchema = z.object({
+	name: z.string(),
+	setupScript: z.string().optional(),
+	repos: z.array(workspaceRepoInputSchema)
+}).strict();
+const workspaceParamsSchema = z.object({ id: z.string().uuid() }).strict();
+const deleteWorkspaceResponseSchema = z.object({ deleted: z.literal(true) }).strict();
+//#endregion
+//#region src/api/schema/stats.ts
+const statSchema = z.object({
+	count: z.number().int().nonnegative(),
+	date: z.string(),
+	metric: z.string().min(1),
+	name: z.string().min(1),
+	namespace: z.string().min(1)
+}).strict();
+const statsReportSchema = z.object({
+	generatedAt: z.string().datetime(),
+	stats: z.array(statSchema),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+export { sumUtcHoursIntoSixHours as $, actorProfileReportSchema as A, createConversationMessageBodySchema as At, dailyConversationActivitySchema as B, createPersonalTokenBodySchema as C, conversationPendingMessageSchema as Ct, personalTokenParamsSchema as D, conversationStatsReportSchema as Dt, personalTokenMetadataSchema as E, conversationReportEventSchema as Et, locationDirectoryReportSchema as F, codePersonReportSchema as G, codeChangeSummaryReportSchema as H, locationParamsSchema as I, HOUR_MS as J, codeRepositorySummarySchema as K, activityDays as L, personalSpendReportSchema as M, locationActivityDayReportSchema as N, revokePersonalTokenResponseSchema as O, conversationSummaryReportSchema as Ot, locationDetailReportSchema as P, startOfUtcHour as Q, activityHours as R, taskSummarySchema as S, conversationPendingMessageDeliverySchema as St, personalTokenListSchema as T, conversationReportEventDataSchema as Tt, codeChangeSummarySchema as U, codeActivityDaySchema as V, codeOverviewReportSchema as W, fillUtcHours as X, fillUtcDays as Y, fillUtcSixHours as Z, taskListSchema as _, conversationEventsQuerySchema as _t, workspaceBodySchema as a, acceptedConversationMessageSchema as at, taskRunSchema as b, conversationParamsSchema as bt, workspaceRepoSchema as c, cancelConversationPendingMessagesBodySchema as ct, scheduledTaskSummarySchema as d, conversationAttachmentParamsSchema as dt, trailingUtcDayWindow as et, taskExecutionListSchema as f, conversationAuxiliaryCostsSchema as ft, taskListQuerySchema as g, conversationEventPageSchema as gt, taskExecutionStatusSchema as h, conversationEventHistorySchema as ht, deleteWorkspaceResponseSchema as i, utcHourKey as it, personParamsSchema as j, apiErrorSchema as jt, actorDirectoryReportSchema as k, createConversationBodySchema as kt, workspaceSchema as l, cancelConversationPendingMessagesResponseSchema as lt, taskExecutionStatusDaySchema as m, conversationDetailReportSchema as mt, statsReportSchema as n, trailingUtcSixHourWindow as nt, workspaceListSchema as o, archiveConversationBodySchema as ot, taskExecutionSchema as p, conversationDetailQuerySchema as pt, DAY_MS as q, baselineSnapshotSchema as r, utcDayKey as rt, workspaceParamsSchema as s, archiveConversationResponseSchema as st, statSchema as t, trailingUtcHourWindow as tt, eventTaskSummarySchema as u, conversationActivityPreviewSchema as ut, taskParamsSchema as v, conversationFeedQuerySchema as vt, createdPersonalTokenSchema as w, conversationPendingMessagesReportSchema as wt, taskRunWindowsSchema as x, conversationPendingAuthorizationSchema as xt, taskRunListSchema as y, conversationFeedSchema as yt, activitySixHours as z };