@sentry/junior 0.177.0 → 0.179.0

package/dist/chunk-XZY6G5YZ.js

@@ -0,0 +1,1088 @@
+import {
+  ToolInputError,
+  canRouteResourceEvents,
+  getPlugins
+} from "./chunk-3I7XE3PA.js";
+import {
+  getDb
+} from "./chunk-VP4OVRDD.js";
+import {
+  juniorAttachments,
+  juniorConversations,
+  juniorEventTasks,
+  juniorSchedulerRuns,
+  juniorSchedulerTasks,
+  juniorStats
+} from "./chunk-R6U7N4FS.js";
+import {
+  juniorDestinations
+} from "./chunk-VFUK3X5B.js";
+
+// src/chat/resource-events/catalog.ts
+import {
+  normalizeResourceEventIdentifier
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+function enumSchema(values, unavailableMessage) {
+  if (values.length === 0) {
+    return z.string().refine(() => false, unavailableMessage);
+  }
+  return z.enum(values);
+}
+function eventNamespaceSchema(catalog) {
+  return enumSchema(
+    Object.keys(catalog).sort(),
+    "No resource event namespaces are enabled."
+  );
+}
+function registeredEventTypeSchema(catalog) {
+  return enumSchema(
+    [
+      ...new Set(
+        Object.values(catalog).flatMap(
+          (registration) => registration.resourceTypes.flatMap(
+            (resourceType) => resourceType.supportedEvents
+          )
+        )
+      )
+    ].sort(),
+    "No resource event types are enabled."
+  );
+}
+function registeredResourceTypeSchema(catalog) {
+  return enumSchema(
+    [
+      ...new Set(
+        Object.values(catalog).flatMap(
+          (registration) => registration.resourceTypes.map((resourceType) => resourceType.type)
+        )
+      )
+    ].sort(),
+    "No resource types are enabled."
+  );
+}
+function pluginSupportsEvent(catalog, namespace, resourceType, eventType) {
+  return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.supportedEvents.includes(eventType) ?? false;
+}
+function resourceEventGuidance(catalog, namespace, resourceType, eventType) {
+  return catalog[namespace]?.resourceTypes.find(
+    (candidate) => candidate.type === resourceType
+  )?.guidance?.[eventType];
+}
+function normalizeEventIdentifier(catalog, namespace, identifier) {
+  return normalizeResourceEventIdentifier(catalog[namespace], identifier);
+}
+
+// src/chat/resource-events/runtime-catalog.ts
+function getResourceEventCatalog() {
+  return Object.fromEntries(
+    canRouteResourceEvents() ? getPlugins().flatMap((plugin) => {
+      const registration = plugin.resourceEvents;
+      if (!registration || registration.isEnabled?.() === false) {
+        return [];
+      }
+      return [[plugin.manifest.name, registration]];
+    }) : []
+  );
+}
+
+// src/chat/event-tasks/store.ts
+import { and, asc, desc, eq, inArray, or, sql } from "drizzle-orm";
+
+// src/chat/event-tasks/types.ts
+import {
+  destinationVisibilitySchema,
+  resourceEventTypeSchema,
+  slackActorSchema,
+  slackDestinationSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var EVENT_TASK_IDENTIFIER_MAX_LENGTH = 300;
+var eventTaskPrincipalSchema = z2.object({
+  slackUserId: slackActorSchema.shape.userId,
+  fullName: z2.string().optional(),
+  userName: z2.string().optional()
+}).strict();
+var eventTaskTriggerSchema = z2.object({
+  events: z2.array(resourceEventTypeSchema).min(1),
+  label: z2.string().min(1),
+  namespace: z2.string().min(1),
+  identifier: z2.string().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
+  resourceType: z2.string().min(1)
+}).strict();
+var eventTaskSchema = z2.object({
+  id: z2.string().min(1),
+  createdAtMs: z2.number().finite(),
+  createdBy: eventTaskPrincipalSchema,
+  credentialMode: z2.enum(["system", "creator"]),
+  destination: slackDestinationSchema,
+  destinationVisibility: destinationVisibilitySchema,
+  task: z2.object({ text: z2.string().min(1) }).strict(),
+  trigger: eventTaskTriggerSchema
+}).strict();
+
+// src/chat/event-tasks/store.ts
+function eventTaskJsonPayload(task) {
+  const { title: _title, ...payload } = task;
+  return payload;
+}
+function parseTask(row) {
+  const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
+  if (raw && typeof raw === "object" && "title" in raw) {
+    delete raw.title;
+  }
+  const payload = eventTaskSchema.parse(raw);
+  const title = row.title?.trim();
+  return title ? { ...payload, title } : payload;
+}
+async function getEventTask(db, id) {
+  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).where(eq(juniorEventTasks.id, id)).limit(1);
+  return rows[0] ? parseTask(rows[0]) : void 0;
+}
+async function createEventTask(db, task) {
+  const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
+  const title = task.title?.trim() || null;
+  await db.insert(juniorEventTasks).values({
+    id: parsed.id,
+    teamId: parsed.destination.teamId,
+    namespace: parsed.trigger.namespace,
+    identifier: parsed.trigger.identifier,
+    createdAtMs: parsed.createdAtMs,
+    title,
+    task: parsed
+  }).onConflictDoNothing();
+  return await getEventTask(db, parsed.id) ?? { ...parsed, ...title ? { title } : {} };
+}
+async function saveEventTask(db, task) {
+  const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
+  const title = task.title?.trim() || null;
+  const rows = await db.update(juniorEventTasks).set({
+    namespace: parsed.trigger.namespace,
+    identifier: parsed.trigger.identifier,
+    title,
+    task: parsed
+  }).where(eq(juniorEventTasks.id, parsed.id)).returning({ task: juniorEventTasks.task, title: juniorEventTasks.title });
+  return rows[0] ? parseTask(rows[0]) : void 0;
+}
+async function deleteEventTask(db, id) {
+  const rows = await db.delete(juniorEventTasks).where(eq(juniorEventTasks.id, id)).returning({ task: juniorEventTasks.task, title: juniorEventTasks.title });
+  return rows[0] ? parseTask(rows[0]) : void 0;
+}
+async function listEventTasksForTeam(db, teamId) {
+  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).where(eq(juniorEventTasks.teamId, teamId)).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
+  return rows.map(parseTask);
+}
+function viewerSlackIdentities(user) {
+  return user.identities.filter(
+    (identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId)
+  );
+}
+function eventTaskBelongsToUser(task, user) {
+  return viewerSlackIdentities(user).some(
+    (identity) => identity.providerTenantId === task.destination.teamId && identity.providerSubjectId === task.createdBy.slackUserId
+  );
+}
+async function listEventTasksCreatedBy(db, user, limit) {
+  const identities = viewerSlackIdentities(user);
+  const ownership = or(
+    ...identities.map(
+      (identity) => and(
+        eq(juniorEventTasks.teamId, identity.providerTenantId),
+        sql`${juniorEventTasks.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`
+      )
+    )
+  );
+  if (!ownership) return [];
+  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).where(ownership).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
+  return rows.map(parseTask);
+}
+async function listPublicEventTasksForTeams(db, teamIds, limit) {
+  if (teamIds.length === 0) return [];
+  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).innerJoin(
+    juniorDestinations,
+    and(
+      eq(juniorDestinations.provider, "slack"),
+      eq(juniorDestinations.providerTenantId, juniorEventTasks.teamId),
+      sql`${juniorDestinations.providerDestinationId} = ${juniorEventTasks.task}->'destination'->>'channelId'`
+    )
+  ).where(
+    and(
+      inArray(juniorEventTasks.teamId, teamIds),
+      eq(juniorDestinations.visibility, "public")
+    )
+  ).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
+  return rows.map(parseTask);
+}
+async function findMatchingEventTasks(db, event, teamId) {
+  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).where(
+    and(
+      eq(juniorEventTasks.teamId, teamId),
+      eq(juniorEventTasks.namespace, event.namespace),
+      eq(juniorEventTasks.identifier, event.identifier)
+    )
+  ).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
+  return rows.map(parseTask).filter((task) => task.trigger.events.includes(event.eventType));
+}
+
+// src/stats.ts
+import { and as and2, asc as asc2, gte, lte, sql as sql2 } from "drizzle-orm";
+function utcDate(nowMs) {
+  return new Date(nowMs).toISOString().slice(0, 10);
+}
+async function incrementStat(key, options = {}) {
+  const date = utcDate(options.nowMs ?? Date.now());
+  await getDb().insert(juniorStats).values({ ...key, date, count: 1 }).onConflictDoUpdate({
+    target: [
+      juniorStats.date,
+      juniorStats.namespace,
+      juniorStats.metric,
+      juniorStats.name
+    ],
+    set: { count: sql2`${juniorStats.count} + 1` }
+  });
+}
+async function readStats(start, end) {
+  return await getDb().select().from(juniorStats).where(and2(gte(juniorStats.date, start), lte(juniorStats.date, end))).orderBy(
+    asc2(juniorStats.date),
+    asc2(juniorStats.namespace),
+    asc2(juniorStats.metric),
+    asc2(juniorStats.name)
+  );
+}
+
+// src/chat/tool-support/structured-result.ts
+import { z as z3 } from "zod";
+var juniorToolContinuationSchema = z3.object({
+  arguments: z3.record(z3.string(), z3.unknown()),
+  reason: z3.string().min(1).optional()
+}).strict();
+var juniorToolBoundContinuationSchema = juniorToolContinuationSchema.extend({
+  tool_name: z3.string().min(1)
+});
+var juniorToolOutputSchema = z3.object({
+  target: z3.string().min(1).optional(),
+  truncated: z3.boolean().optional(),
+  /** True when this attempt did not finish before its time budget. */
+  timed_out: z3.boolean().optional(),
+  continuation: juniorToolContinuationSchema.optional()
+}).passthrough();
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortJsonValue(item)])
+  );
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function injectContinuationToolName(details, toolName) {
+  if (!isRecord(details) || !isRecord(details.continuation)) {
+    return details;
+  }
+  return {
+    ...details,
+    continuation: juniorToolBoundContinuationSchema.parse({
+      ...details.continuation,
+      tool_name: toolName
+    })
+  };
+}
+function makeStructuredToolOutput(details, options = {}) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(sortJsonValue(details))
+      },
+      ...options.content ?? []
+    ],
+    details
+  };
+}
+
+// src/chat/event-tasks/tool-support.ts
+import { z as z4 } from "zod";
+var compactEventTaskResultSchema = z4.object({
+  id: z4.string().min(1),
+  task: z4.string().min(1),
+  namespace: z4.string().min(1),
+  identifier: z4.string().min(1),
+  resourceType: z4.string().min(1),
+  label: z4.string().min(1),
+  events: z4.array(z4.string().min(1)).min(1),
+  credentialMode: z4.enum(["system", "creator"]),
+  createdBy: eventTaskPrincipalSchema,
+  triggerAvailable: z4.boolean()
+}).strict();
+var eventTaskToolResultSchema = juniorToolOutputSchema.extend({
+  task: compactEventTaskResultSchema
+}).strict();
+var eventTaskListToolResultSchema = juniorToolOutputSchema.extend({
+  tasks: z4.array(compactEventTaskResultSchema),
+  truncated: z4.boolean()
+}).strict();
+function registeredEventTaskTriggerSchema(catalog) {
+  return z4.object({
+    namespace: eventNamespaceSchema(catalog),
+    identifier: z4.string().trim().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
+    resourceType: registeredResourceTypeSchema(catalog),
+    label: z4.string().trim().min(1).max(500),
+    events: z4.array(registeredEventTypeSchema(catalog)).min(1)
+  }).strict();
+}
+function requireSupportedEventTaskTrigger(catalog, trigger) {
+  for (const eventType of trigger.events) {
+    if (!pluginSupportsEvent(
+      catalog,
+      trigger.namespace,
+      trigger.resourceType,
+      eventType
+    )) {
+      throw new ToolInputError(
+        `Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`
+      );
+    }
+  }
+}
+function requireEventTaskSlackContext(context) {
+  if (context.source.platform !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) {
+    throw new ToolInputError(
+      "Event tasks require an active Slack channel or DM and actor."
+    );
+  }
+  return {
+    actor: context.actor,
+    destination: {
+      platform: "slack",
+      teamId: context.source.teamId,
+      channelId: context.source.channelId
+    },
+    source: context.source
+  };
+}
+function eventTaskMatchesDestination(task, destination) {
+  return task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
+}
+async function writableEventTask(context, id) {
+  const { destination } = requireEventTaskSlackContext(context);
+  const task = await getEventTask(getDb(), id);
+  if (!task || !eventTaskMatchesDestination(task, destination)) {
+    throw new ToolInputError(
+      "Event task was not found in this Slack channel or DM."
+    );
+  }
+  return task;
+}
+function eventTaskTriggerAvailable(task, catalog) {
+  const registration = catalog[task.trigger.namespace];
+  return Boolean(
+    registration && task.trigger.events.every(
+      (eventType) => registration.resourceTypes.some(
+        (resourceType) => resourceType.supportedEvents.includes(eventType)
+      )
+    )
+  );
+}
+function compactEventTask(task, catalog) {
+  return compactEventTaskResultSchema.parse({
+    id: task.id,
+    task: task.task.text,
+    namespace: task.trigger.namespace,
+    identifier: task.trigger.identifier,
+    resourceType: task.trigger.resourceType,
+    label: task.trigger.label,
+    events: task.trigger.events,
+    credentialMode: task.credentialMode,
+    createdBy: task.createdBy,
+    triggerAvailable: eventTaskTriggerAvailable(task, catalog)
+  });
+}
+function eventTaskSuccess(task, catalog) {
+  return {
+    task: compactEventTask(task, catalog)
+  };
+}
+
+// src/chat/scheduled-tasks/tasks.ts
+import { and as and3, asc as asc3, desc as desc2, eq as eq2, inArray as inArray2, notInArray, sql as sql3 } from "drizzle-orm";
+import { z as z6 } from "zod";
+
+// src/chat/scheduled-tasks/types.ts
+import {
+  slackActorSchema as slackActorSchema2,
+  slackDestinationSchema as slackDestinationSchema2
+} from "@sentry/junior-plugin-api";
+import { z as z5 } from "zod";
+var scheduledTaskStatusSchema = z5.enum([
+  "active",
+  "blocked",
+  "completed",
+  "deleted"
+]);
+var scheduledTaskCredentialModeSchema = z5.enum(["system", "creator"]);
+var scheduledRunStatusSchema = z5.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "blocked",
+  "skipped"
+]);
+var scheduledTaskPrincipalSchema = z5.object({
+  slackUserId: slackActorSchema2.shape.userId,
+  fullName: z5.string().optional(),
+  userName: z5.string().optional()
+}).strict();
+var scheduledTaskRecurrenceSchema = z5.object({
+  dayOfMonth: z5.number().optional(),
+  frequency: z5.enum(["daily", "weekly", "monthly", "yearly"]),
+  interval: z5.number(),
+  month: z5.number().optional(),
+  startDate: z5.string(),
+  time: z5.object({
+    hour: z5.number(),
+    minute: z5.number()
+  }).strict(),
+  weekdays: z5.array(z5.number()).optional()
+}).strict();
+var scheduledTaskScheduleSchema = z5.object({
+  description: z5.string(),
+  kind: z5.enum(["one_off", "recurring"]),
+  recurrence: scheduledTaskRecurrenceSchema.optional(),
+  timezone: z5.string()
+}).strict();
+var scheduledTaskExecutionActorSchema = z5.object({
+  platform: z5.literal("system"),
+  name: z5.string()
+}).strict();
+var scheduledTaskSchema = z5.object({
+  id: z5.string(),
+  conversationAccess: z5.object({
+    audience: z5.enum(["direct", "group", "channel"]),
+    visibility: z5.enum(["private", "public"])
+  }).strict(),
+  createdAtMs: z5.number(),
+  createdBy: scheduledTaskPrincipalSchema,
+  /** Authoritative provider identity that created the task. */
+  creatorIdentityId: z5.string(),
+  /** Selects system credentials or task-bound creator credential delegation. */
+  credentialMode: scheduledTaskCredentialModeSchema,
+  destination: slackDestinationSchema2,
+  executionActor: scheduledTaskExecutionActorSchema.optional(),
+  lastRunAtMs: z5.number().optional(),
+  nextRunAtMs: z5.number().optional(),
+  originalRequest: z5.string().optional(),
+  runNowAtMs: z5.number().optional(),
+  schedule: scheduledTaskScheduleSchema,
+  status: scheduledTaskStatusSchema,
+  statusReason: z5.string().optional(),
+  task: z5.object({ text: z5.string() }).strict(),
+  /** SQL-backed short display title generated from the task instruction. */
+  title: z5.string().optional(),
+  updatedAtMs: z5.number()
+}).strict();
+var scheduledRunSchema = z5.object({
+  id: z5.string(),
+  attempt: z5.number(),
+  claimedAtMs: z5.number(),
+  completedAtMs: z5.number().optional(),
+  dispatchId: z5.string().optional(),
+  errorMessage: z5.string().optional(),
+  resultMessageTs: z5.string().optional(),
+  scheduledForMs: z5.number(),
+  startedAtMs: z5.number().optional(),
+  status: scheduledRunStatusSchema,
+  taskId: z5.string()
+}).strict();
+var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
+  platform: "system",
+  name: "scheduled-task"
+});
+
+// src/chat/scheduled-tasks/tasks.ts
+var SCHEDULER_KEY_PREFIX = "junior:scheduler";
+var retainedScheduledTaskSchema = scheduledTaskSchema.omit({ creatorIdentityId: true, title: true }).extend({
+  // TODO(v0.131.0): Remove paused decoding and SQL list filtering after
+  // v0.129.x workers can no longer overlap upgrades.
+  status: z6.enum(["active", "blocked", "completed", "deleted", "paused"]),
+  version: z6.number().optional()
+}).strict();
+function parseScheduledTaskRow(row) {
+  const record = z6.record(z6.string(), z6.unknown()).safeParse(row.record);
+  if (!record.success) return void 0;
+  const {
+    creatorIdentityId: legacyCreatorIdentityId,
+    title: legacyTitle,
+    ...retained
+  } = record.data;
+  const parsed = retainedScheduledTaskSchema.safeParse(retained);
+  if (!parsed.success) return void 0;
+  const { status, version: _version, ...task } = parsed.data;
+  const fallbackIdentity = row.creatorIdentityId === null ? z6.string().safeParse(legacyCreatorIdentityId) : void 0;
+  const creatorIdentityId = row.creatorIdentityId ?? (fallbackIdentity?.success ? fallbackIdentity.data : void 0);
+  if (creatorIdentityId === void 0) return void 0;
+  const fallbackTitle = row.title === null ? z6.string().safeParse(legacyTitle) : void 0;
+  const titleSource = row.title !== null ? row.title : fallbackTitle?.success ? fallbackTitle.data : void 0;
+  const title = titleSource?.trim() || void 0;
+  if (status === "paused") {
+    const {
+      nextRunAtMs: _nextRunAtMs,
+      runNowAtMs: _runNowAtMs,
+      ...retained2
+    } = task;
+    return {
+      ...retained2,
+      creatorIdentityId,
+      status: "deleted",
+      ...title ? { title } : {}
+    };
+  }
+  return {
+    ...task,
+    creatorIdentityId,
+    status,
+    ...title ? { title } : {}
+  };
+}
+function isListedScheduledTask(task) {
+  return task !== void 0 && task.status !== "deleted";
+}
+function scheduledRunId(taskId, scheduledForMs) {
+  return `${taskId}:${scheduledForMs}`;
+}
+function withScheduledTaskLock(db, taskId, callback) {
+  return db.transaction(async (tx) => {
+    await tx.execute(
+      sql3`SELECT pg_advisory_xact_lock(hashtext(${`${SCHEDULER_KEY_PREFIX}:task:${taskId}:lock`}))`
+    );
+    return await callback(tx);
+  });
+}
+function requireStoredTask(task) {
+  const parsed = scheduledTaskSchema.safeParse(task);
+  if (!parsed.success) {
+    throw new Error("Scheduled task routing context is invalid.");
+  }
+  const { title, ...current } = parsed.data;
+  const normalizedTitle = title?.trim() || void 0;
+  return { ...current, ...normalizedTitle ? { title: normalizedTitle } : {} };
+}
+function scheduledTaskJsonRecord(task) {
+  const { title: _title, ...record } = task;
+  return record;
+}
+async function upsertScheduledTask(db, task) {
+  const title = task.title?.trim() || null;
+  await db.insert(juniorSchedulerTasks).values({
+    createdAtMs: task.createdAtMs,
+    creatorIdentityId: task.creatorIdentityId,
+    // TODO(v0.128.0): Remove after v0.127.x runtimes no longer read this column.
+    creatorSlackUserId: task.createdBy.slackUserId,
+    id: task.id,
+    nextRunAtMs: task.nextRunAtMs,
+    record: scheduledTaskJsonRecord(task),
+    runNowAtMs: task.runNowAtMs,
+    status: task.status,
+    teamId: task.destination.teamId,
+    title
+  }).onConflictDoUpdate({
+    target: juniorSchedulerTasks.id,
+    set: {
+      createdAtMs: sql3`excluded.created_at_ms`,
+      creatorIdentityId: sql3`excluded.creator_identity_id`,
+      creatorSlackUserId: sql3`excluded.creator_slack_user_id`,
+      nextRunAtMs: sql3`excluded.next_run_at_ms`,
+      record: sql3`excluded.record`,
+      runNowAtMs: sql3`excluded.run_now_at_ms`,
+      status: sql3`excluded.status`,
+      teamId: sql3`excluded.team_id`,
+      title: sql3`excluded.title`
+    }
+  });
+}
+async function readScheduledTask(db, taskId) {
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record,
+    title: juniorSchedulerTasks.title
+  }).from(juniorSchedulerTasks).where(eq2(juniorSchedulerTasks.id, taskId)).limit(1);
+  return rows[0] ? parseScheduledTaskRow(rows[0]) : void 0;
+}
+async function readListedScheduledTasks(db, teamId) {
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record,
+    title: juniorSchedulerTasks.title
+  }).from(juniorSchedulerTasks).where(
+    and3(
+      notInArray(juniorSchedulerTasks.status, ["deleted", "paused"]),
+      teamId === void 0 ? void 0 : eq2(juniorSchedulerTasks.teamId, teamId)
+    )
+  ).orderBy(
+    asc3(juniorSchedulerTasks.createdAtMs),
+    asc3(juniorSchedulerTasks.id)
+  );
+  return rows.map(parseScheduledTaskRow).filter(isListedScheduledTask);
+}
+async function listScheduledTasks(db) {
+  return await readListedScheduledTasks(db);
+}
+async function listScheduledTasksForTeam(db, teamId) {
+  return await readListedScheduledTasks(db, teamId);
+}
+async function writeScheduledTask(db, task, current) {
+  if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) {
+    await db.delete(juniorSchedulerRuns).where(
+      and3(
+        eq2(juniorSchedulerRuns.id, scheduledRunId(task.id, task.nextRunAtMs)),
+        eq2(juniorSchedulerRuns.status, "blocked")
+      )
+    );
+  }
+  await upsertScheduledTask(db, task);
+}
+async function createScheduledTask(db, task) {
+  const next = requireStoredTask(task);
+  return await withScheduledTaskLock(db, task.id, async (tx) => {
+    const current = await readScheduledTask(tx, task.id);
+    if (current) return current;
+    await writeScheduledTask(tx, next, void 0);
+    return next;
+  });
+}
+async function saveScheduledTask(db, task) {
+  const next = requireStoredTask(task);
+  await withScheduledTaskLock(db, task.id, async (tx) => {
+    const current = await readScheduledTask(tx, task.id);
+    await writeScheduledTask(tx, next, current);
+  });
+  return next;
+}
+async function saveScheduledTaskInLock(db, task, current) {
+  await writeScheduledTask(db, requireStoredTask(task), current);
+}
+async function listPublicScheduledTasksForTeams(db, teamIds, limit) {
+  if (teamIds.length === 0) return [];
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record,
+    title: juniorSchedulerTasks.title
+  }).from(juniorSchedulerTasks).innerJoin(
+    juniorDestinations,
+    and3(
+      eq2(juniorDestinations.provider, "slack"),
+      eq2(juniorDestinations.providerTenantId, juniorSchedulerTasks.teamId),
+      sql3`${juniorDestinations.providerDestinationId} = ${juniorSchedulerTasks.record}->'destination'->>'channelId'`
+    )
+  ).where(
+    and3(
+      inArray2(juniorSchedulerTasks.teamId, teamIds),
+      notInArray(juniorSchedulerTasks.status, [
+        "completed",
+        "deleted",
+        "paused"
+      ]),
+      eq2(juniorDestinations.visibility, "public")
+    )
+  ).orderBy(
+    desc2(juniorSchedulerTasks.createdAtMs),
+    desc2(juniorSchedulerTasks.id)
+  ).limit(limit);
+  return rows.map(parseScheduledTaskRow).filter(isListedScheduledTask);
+}
+
+// src/chat/attachments/store.ts
+import { createHash, randomUUID } from "crypto";
+import { and as and4, asc as asc4, eq as eq3, inArray as inArray3, isNotNull, isNull, or as or2 } from "drizzle-orm";
+var ATTACHMENT_GC_BATCH_LIMIT = 200;
+function attachmentDigest(file) {
+  return createHash("sha256").update(file.data).digest("hex");
+}
+function attachmentId(args) {
+  return createHash("sha256").update(
+    [
+      args.conversationId,
+      args.provider,
+      args.sha256,
+      args.filename,
+      args.contentType
+    ].join("\0")
+  ).digest("hex");
+}
+function attachmentKey(args) {
+  return `conversations/${args.conversationId}/attachments/${args.attachmentId}/${args.writeId}/${args.filename}`;
+}
+async function bestEffortDelete(storage, key) {
+  try {
+    await storage.delete([key]);
+  } catch {
+  }
+}
+async function isConversationPurged(db, conversationId) {
+  const [row] = await db.db().select({
+    transcriptPurgedAt: juniorConversations.transcriptPurgedAt
+  }).from(juniorConversations).where(eq3(juniorConversations.conversationId, conversationId));
+  return row?.transcriptPurgedAt != null;
+}
+function purgedConversationError(conversationId) {
+  return new Error(
+    `Cannot store attachment for purged conversation ${conversationId}`
+  );
+}
+async function assertConversationNotPurged(db, conversationId) {
+  if (await isConversationPurged(db, conversationId)) {
+    throw purgedConversationError(conversationId);
+  }
+}
+async function rejectPurgedAttachmentWrite(args) {
+  await args.db.db().update(juniorAttachments).set({ deleteRequestedAt: args.now }).where(eq3(juniorAttachments.id, args.id));
+  await bestEffortDelete(args.storage, args.storageKey);
+  throw purgedConversationError(args.conversationId);
+}
+async function reuseLiveAttachment(args) {
+  await bestEffortDelete(args.storage, args.storageKey);
+  await assertConversationNotPurged(args.db, args.conversationId);
+  return { id: args.id };
+}
+async function storeAttachment(args) {
+  const now = new Date(args.nowMs ?? Date.now());
+  const sha256 = attachmentDigest(args.file);
+  const id = attachmentId({
+    conversationId: args.conversationId,
+    contentType: args.file.mimeType,
+    filename: args.file.filename,
+    provider: args.storage.provider,
+    sha256
+  });
+  const [existing] = await args.db.db().select({
+    contentType: juniorAttachments.contentType,
+    conversationId: juniorAttachments.conversationId,
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    filename: juniorAttachments.filename,
+    id: juniorAttachments.id,
+    provider: juniorAttachments.provider,
+    sha256: juniorAttachments.sha256,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+  if (existing) {
+    if (existing.contentType !== args.file.mimeType || existing.conversationId !== args.conversationId || existing.filename !== args.file.filename || existing.provider !== args.storage.provider || existing.sha256 !== sha256) {
+      throw new Error(`Attachment write conflicts with ${existing.id}`);
+    }
+    if (existing.deleteRequestedAt === null) {
+      await assertConversationNotPurged(args.db, args.conversationId);
+      return { id: existing.id };
+    }
+  }
+  await assertConversationNotPurged(args.db, args.conversationId);
+  const storageKey = attachmentKey({
+    attachmentId: id,
+    conversationId: args.conversationId,
+    filename: args.file.filename,
+    writeId: randomUUID()
+  });
+  await args.storage.put({
+    body: args.file.data,
+    contentType: args.file.mimeType,
+    key: storageKey
+  });
+  if (existing?.deleteRequestedAt != null) {
+    if (await isConversationPurged(args.db, args.conversationId)) {
+      await bestEffortDelete(args.storage, storageKey);
+      throw purgedConversationError(args.conversationId);
+    }
+    const oldStorageKey = existing.storageKey;
+    const revived2 = await args.db.db().update(juniorAttachments).set({
+      deleteRequestedAt: null,
+      storageKey
+    }).where(
+      and4(
+        eq3(juniorAttachments.id, id),
+        isNotNull(juniorAttachments.deleteRequestedAt)
+      )
+    ).returning({ id: juniorAttachments.id });
+    if (revived2.length > 0) {
+      if (await isConversationPurged(args.db, args.conversationId)) {
+        await rejectPurgedAttachmentWrite({
+          conversationId: args.conversationId,
+          db: args.db,
+          id,
+          now,
+          storage: args.storage,
+          storageKey
+        });
+      }
+      if (oldStorageKey !== storageKey) {
+        await bestEffortDelete(args.storage, oldStorageKey);
+      }
+      return { id };
+    }
+    const [afterRace2] = await args.db.db().select({
+      deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+      id: juniorAttachments.id,
+      storageKey: juniorAttachments.storageKey
+    }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+    if (afterRace2?.deleteRequestedAt === null) {
+      return reuseLiveAttachment({
+        conversationId: args.conversationId,
+        db: args.db,
+        id: afterRace2.id,
+        storage: args.storage,
+        storageKey
+      });
+    }
+  }
+  let inserted = [];
+  try {
+    inserted = await args.db.db().insert(juniorAttachments).values({
+      id,
+      conversationId: args.conversationId,
+      provider: args.storage.provider,
+      storageKey,
+      filename: args.file.filename,
+      contentType: args.file.mimeType,
+      bytes: args.file.bytes,
+      sha256,
+      createdAt: now
+    }).onConflictDoNothing({ target: juniorAttachments.id }).returning({ id: juniorAttachments.id });
+  } catch (error) {
+    await bestEffortDelete(args.storage, storageKey);
+    throw error;
+  }
+  if (inserted.length > 0) {
+    if (await isConversationPurged(args.db, args.conversationId)) {
+      await rejectPurgedAttachmentWrite({
+        conversationId: args.conversationId,
+        db: args.db,
+        id,
+        now,
+        storage: args.storage,
+        storageKey
+      });
+    }
+    return { id };
+  }
+  const [row] = await args.db.db().select({
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    id: juniorAttachments.id,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+  if (!row) {
+    await bestEffortDelete(args.storage, storageKey);
+    throw new Error(`Attachment row missing after write for ${id}`);
+  }
+  if (row.deleteRequestedAt === null) {
+    return reuseLiveAttachment({
+      conversationId: args.conversationId,
+      db: args.db,
+      id: row.id,
+      storage: args.storage,
+      storageKey
+    });
+  }
+  if (await isConversationPurged(args.db, args.conversationId)) {
+    await bestEffortDelete(args.storage, storageKey);
+    throw purgedConversationError(args.conversationId);
+  }
+  const revived = await args.db.db().update(juniorAttachments).set({
+    deleteRequestedAt: null,
+    storageKey
+  }).where(
+    and4(
+      eq3(juniorAttachments.id, id),
+      isNotNull(juniorAttachments.deleteRequestedAt)
+    )
+  ).returning({ id: juniorAttachments.id });
+  if (revived.length > 0) {
+    if (await isConversationPurged(args.db, args.conversationId)) {
+      await rejectPurgedAttachmentWrite({
+        conversationId: args.conversationId,
+        db: args.db,
+        id,
+        now,
+        storage: args.storage,
+        storageKey
+      });
+    }
+    if (row.storageKey !== storageKey) {
+      await bestEffortDelete(args.storage, row.storageKey);
+    }
+    return { id };
+  }
+  const [afterRace] = await args.db.db().select({
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    id: juniorAttachments.id
+  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+  if (afterRace?.deleteRequestedAt === null) {
+    return reuseLiveAttachment({
+      conversationId: args.conversationId,
+      db: args.db,
+      id: afterRace.id,
+      storage: args.storage,
+      storageKey
+    });
+  }
+  await bestEffortDelete(args.storage, storageKey);
+  throw new Error(`Attachment ${id} disappeared while reviving`);
+}
+async function readLiveAttachment(args) {
+  const [row] = await args.db.db().select({
+    bytes: juniorAttachments.bytes,
+    contentType: juniorAttachments.contentType,
+    conversationId: juniorAttachments.conversationId,
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    filename: juniorAttachments.filename,
+    id: juniorAttachments.id,
+    provider: juniorAttachments.provider,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).where(
+    and4(
+      eq3(juniorAttachments.id, args.attachmentId),
+      eq3(juniorAttachments.conversationId, args.conversationId),
+      isNull(juniorAttachments.deleteRequestedAt)
+    )
+  );
+  if (!row) return null;
+  if (await isConversationPurged(args.db, args.conversationId)) {
+    return null;
+  }
+  return {
+    bytes: row.bytes,
+    contentType: row.contentType,
+    conversationId: row.conversationId,
+    filename: row.filename,
+    id: row.id,
+    provider: row.provider,
+    storageKey: row.storageKey
+  };
+}
+async function storeAttachments(args) {
+  const stored = [];
+  for (const file of args.files) {
+    stored.push(
+      await storeAttachment({
+        conversationId: args.conversationId,
+        db: args.db,
+        file,
+        ...args.nowMs !== void 0 ? { nowMs: args.nowMs } : {},
+        storage: args.storage
+      })
+    );
+  }
+  return stored;
+}
+async function requestAttachmentDeletion(db, conversationIds, nowMs) {
+  if (conversationIds.length === 0) return;
+  await db.db().update(juniorAttachments).set({ deleteRequestedAt: new Date(nowMs) }).where(
+    and4(
+      inArray3(juniorAttachments.conversationId, conversationIds),
+      isNull(juniorAttachments.deleteRequestedAt)
+    )
+  );
+}
+async function collectAttachmentGarbage(args) {
+  void args.nowMs;
+  const rows = await args.db.db().select({
+    id: juniorAttachments.id,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).innerJoin(
+    juniorConversations,
+    eq3(
+      juniorAttachments.conversationId,
+      juniorConversations.conversationId
+    )
+  ).where(
+    and4(
+      eq3(juniorAttachments.provider, args.storage.provider),
+      or2(
+        isNotNull(juniorAttachments.deleteRequestedAt),
+        isNotNull(juniorConversations.transcriptPurgedAt)
+      )
+    )
+  ).orderBy(asc4(juniorAttachments.createdAt), asc4(juniorAttachments.id)).limit(args.limit ?? ATTACHMENT_GC_BATCH_LIMIT);
+  if (rows.length === 0) return { deleted: 0 };
+  await args.storage.delete(rows.map((row) => row.storageKey));
+  const stillEligible = await args.db.db().select({ id: juniorAttachments.id }).from(juniorAttachments).innerJoin(
+    juniorConversations,
+    eq3(
+      juniorAttachments.conversationId,
+      juniorConversations.conversationId
+    )
+  ).where(
+    and4(
+      inArray3(
+        juniorAttachments.id,
+        rows.map((row) => row.id)
+      ),
+      or2(
+        isNotNull(juniorAttachments.deleteRequestedAt),
+        isNotNull(juniorConversations.transcriptPurgedAt)
+      )
+    )
+  );
+  if (stillEligible.length === 0) return { deleted: 0 };
+  const removed = await args.db.db().delete(juniorAttachments).where(
+    inArray3(
+      juniorAttachments.id,
+      stillEligible.map((row) => row.id)
+    )
+  ).returning({
+    id: juniorAttachments.id
+  });
+  return { deleted: removed.length };
+}
+
+export {
+  juniorToolOutputSchema,
+  injectContinuationToolName,
+  makeStructuredToolOutput,
+  eventNamespaceSchema,
+  registeredEventTypeSchema,
+  registeredResourceTypeSchema,
+  pluginSupportsEvent,
+  resourceEventGuidance,
+  normalizeEventIdentifier,
+  getResourceEventCatalog,
+  getEventTask,
+  createEventTask,
+  saveEventTask,
+  deleteEventTask,
+  listEventTasksForTeam,
+  eventTaskBelongsToUser,
+  listEventTasksCreatedBy,
+  listPublicEventTasksForTeams,
+  findMatchingEventTasks,
+  eventTaskToolResultSchema,
+  eventTaskListToolResultSchema,
+  registeredEventTaskTriggerSchema,
+  requireSupportedEventTaskTrigger,
+  requireEventTaskSlackContext,
+  eventTaskMatchesDestination,
+  writableEventTask,
+  eventTaskTriggerAvailable,
+  compactEventTask,
+  eventTaskSuccess,
+  scheduledRunSchema,
+  SCHEDULED_TASK_SYSTEM_ACTOR,
+  parseScheduledTaskRow,
+  isListedScheduledTask,
+  scheduledRunId,
+  withScheduledTaskLock,
+  readScheduledTask,
+  listScheduledTasks,
+  listScheduledTasksForTeam,
+  createScheduledTask,
+  saveScheduledTask,
+  saveScheduledTaskInLock,
+  listPublicScheduledTasksForTeams,
+  readLiveAttachment,
+  storeAttachments,
+  requestAttachmentDeletion,
+  collectAttachmentGarbage,
+  incrementStat,
+  readStats
+};