@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-TXJSXBV5.js

@@ -1,1433 +0,0 @@
-import {
-  ToolInputError
-} from "./chunk-7DHZP5KJ.js";
-import {
-  getPlugins
-} from "./chunk-U2GPUYAL.js";
-import {
-  getDb
-} from "./chunk-M76HMB7M.js";
-import {
-  juniorAttachments,
-  juniorConversations,
-  juniorEventTasks,
-  juniorSchedulerRuns,
-  juniorSchedulerTasks,
-  juniorStats
-} from "./chunk-PW4P4JYF.js";
-import {
-  juniorDestinations
-} from "./chunk-VFUK3X5B.js";
-
-// src/chat/event-tasks/store.ts
-import {
-  resourceEventMatches
-} from "@sentry/junior-plugin-api";
-import { and, asc, desc, eq, inArray, ne, or, sql } from "drizzle-orm";
-
-// src/chat/event-tasks/types.ts
-import {
-  actorUserIdSchema,
-  destinationVisibilitySchema,
-  resourceEventMatchSchema,
-  resourceEventTypeSchema,
-  slackDestinationSchema
-} from "@sentry/junior-plugin-api";
-import { z } from "zod";
-var EVENT_TASK_IDENTIFIER_MAX_LENGTH = 300;
-var eventTaskPrincipalSchema = z.object({
-  slackUserId: actorUserIdSchema,
-  fullName: z.string().optional(),
-  userName: z.string().optional()
-}).strict();
-var eventTaskTriggerSchema = z.object({
-  events: z.array(resourceEventTypeSchema).min(1),
-  label: z.string().min(1),
-  match: resourceEventMatchSchema.optional(),
-  namespace: z.string().min(1),
-  identifier: z.string().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
-  resourceType: z.string().min(1)
-}).strict();
-var eventTaskSchema = z.object({
-  id: z.string().min(1),
-  createdAtMs: z.number().finite(),
-  createdBy: eventTaskPrincipalSchema,
-  credentialMode: z.enum(["system", "creator"]),
-  destination: slackDestinationSchema,
-  destinationVisibility: destinationVisibilitySchema,
-  task: z.object({ text: z.string().min(1) }).strict(),
-  trigger: eventTaskTriggerSchema
-}).strict();
-
-// src/chat/event-tasks/store.ts
-function eventTaskJsonPayload(task) {
-  const {
-    status: _status,
-    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 {
-    ...payload,
-    status: row.status === "deleted" ? "deleted" : "active",
-    ...title ? { title } : void 0
-  };
-}
-function activeEventTaskWhere() {
-  return ne(juniorEventTasks.status, "deleted");
-}
-async function getEventTask(db, id) {
-  const rows = await db.select({
-    status: juniorEventTasks.status,
-    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,
-    status: "active",
-    title,
-    task: parsed
-  }).onConflictDoNothing();
-  const existing = await getEventTask(db, parsed.id);
-  if (!existing) {
-    return {
-      ...parsed,
-      status: "active",
-      ...title ? { title } : void 0
-    };
-  }
-  if (existing.status !== "deleted") {
-    return existing;
-  }
-  const rows = await db.update(juniorEventTasks).set({
-    teamId: parsed.destination.teamId,
-    namespace: parsed.trigger.namespace,
-    identifier: parsed.trigger.identifier,
-    status: "active",
-    title,
-    task: parsed
-  }).where(
-    and(
-      eq(juniorEventTasks.id, parsed.id),
-      eq(juniorEventTasks.status, "deleted")
-    )
-  ).returning({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  });
-  return rows[0] ? parseTask(rows[0]) : await getEventTask(db, parsed.id) ?? {
-    ...parsed,
-    status: "active",
-    ...title ? { title } : void 0
-  };
-}
-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(and(eq(juniorEventTasks.id, parsed.id), activeEventTaskWhere())).returning({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  });
-  return rows[0] ? parseTask(rows[0]) : void 0;
-}
-async function deleteEventTask(db, id) {
-  const rows = await db.update(juniorEventTasks).set({ status: "deleted" }).where(and(eq(juniorEventTasks.id, id), activeEventTaskWhere())).returning({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  });
-  return rows[0] ? parseTask(rows[0]) : void 0;
-}
-async function listEventTasksForTeam(db, teamId) {
-  const rows = await db.select({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  }).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, teamId), activeEventTaskWhere())).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({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  }).from(juniorEventTasks).where(and(ownership, activeEventTaskWhere())).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
-  return rows.map(parseTask);
-}
-async function listDeletedEventTasksCreatedBy(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({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  }).from(juniorEventTasks).where(and(ownership, eq(juniorEventTasks.status, "deleted"))).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({
-    status: juniorEventTasks.status,
-    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),
-      activeEventTaskWhere(),
-      eq(juniorDestinations.visibility, "public")
-    )
-  ).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
-  return rows.map(parseTask);
-}
-async function collectEventTaskMatchKeys(db, input) {
-  const eventTypes = new Set(
-    input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean)
-  );
-  const identifiers = [
-    ...new Set(input.identifiers.map((value) => value.trim()).filter(Boolean))
-  ];
-  if (eventTypes.size === 0 || identifiers.length === 0) return [];
-  const rows = await db.select({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  }).from(juniorEventTasks).where(
-    and(
-      eq(juniorEventTasks.teamId, input.teamId),
-      eq(juniorEventTasks.namespace, input.namespace),
-      inArray(juniorEventTasks.identifier, identifiers),
-      activeEventTaskWhere()
-    )
-  ).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
-  const keys = /* @__PURE__ */ new Set();
-  for (const row of rows) {
-    const task = parseTask(row);
-    if (!task.trigger.events.some((eventType) => eventTypes.has(eventType))) {
-      continue;
-    }
-    for (const key of Object.keys(task.trigger.match ?? {})) {
-      keys.add(key);
-    }
-  }
-  return [...keys].sort();
-}
-async function findMatchingEventTasks(db, event, teamId) {
-  const rows = await db.select({
-    status: juniorEventTasks.status,
-    task: juniorEventTasks.task,
-    title: juniorEventTasks.title
-  }).from(juniorEventTasks).where(
-    and(
-      eq(juniorEventTasks.teamId, teamId),
-      eq(juniorEventTasks.namespace, event.namespace),
-      eq(juniorEventTasks.identifier, event.identifier),
-      activeEventTaskWhere()
-    )
-  ).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
-  return rows.map(parseTask).filter(
-    (task) => task.trigger.events.includes(event.eventType) && resourceEventMatches(task.trigger.match, event.data)
-  );
-}
-
-// 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 z2 } from "zod";
-var juniorToolContinuationSchema = z2.object({
-  arguments: z2.record(z2.string(), z2.unknown()),
-  reason: z2.string().min(1).optional()
-}).strict();
-var juniorToolBoundContinuationSchema = juniorToolContinuationSchema.extend({
-  tool_name: z2.string().min(1)
-});
-var juniorToolOutputSchema = z2.object({
-  target: z2.string().min(1).optional(),
-  truncated: z2.boolean().optional(),
-  /** True when this attempt did not finish before its time budget. */
-  timed_out: z2.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/resource-events/catalog.ts
-import {
-  normalizeResourceEventIdentifier,
-  resourceEventMatchSchema as resourceEventMatchSchema2
-} from "@sentry/junior-plugin-api";
-import { z as z3 } from "zod";
-var CORE_RESOURCE_EVENT_NAMESPACE = "junior";
-function hasResourceEventCatalogEntries(catalog) {
-  return Object.keys(catalog).length > 0;
-}
-function hasPluginResourceEventCatalogEntries(catalog) {
-  return Object.keys(pluginResourceEventCatalog(catalog)).length > 0;
-}
-function pluginResourceEventCatalog(catalog) {
-  return Object.fromEntries(
-    Object.entries(catalog).filter(
-      ([namespace]) => namespace !== CORE_RESOURCE_EVENT_NAMESPACE
-    )
-  );
-}
-function enumSchema(values, unavailableMessage) {
-  if (values.length === 0) {
-    return z3.string().refine(() => false, unavailableMessage);
-  }
-  return z3.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 resourceEventMatchFields(catalog, namespace, resourceType) {
-  return catalog[namespace]?.resourceTypes.find(
-    (candidate) => candidate.type === resourceType
-  )?.matchFields;
-}
-function registeredResourceEventMatchSchema() {
-  return resourceEventMatchSchema2.optional().describe(
-    "Optional exact values from the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. Omit a key to ignore it. Unmatched events are dropped with no agent turn."
-  );
-}
-function requireSupportedResourceEventMatch(catalog, input) {
-  const match = input.match;
-  if (!match || Object.keys(match).length === 0) return void 0;
-  const fields = resourceEventMatchFields(
-    catalog,
-    input.namespace,
-    input.resourceType
-  );
-  if (!fields || Object.keys(fields).length === 0) {
-    throw new ToolInputError(
-      `Resource type "${input.namespace}:${input.resourceType}" does not support match.`
-    );
-  }
-  const normalized = {};
-  for (const [key, value] of Object.entries(match)) {
-    const field = fields[key];
-    if (!field) {
-      throw new ToolInputError(
-        `Resource type "${input.namespace}:${input.resourceType}" does not support match key "${key}".`
-      );
-    }
-    if (Array.isArray(value)) {
-      if (field.kind === "boolean") {
-        throw new ToolInputError(
-          `Match key "${key}" is boolean and cannot use a list.`
-        );
-      }
-      for (const entry of value) {
-        if (typeof entry !== field.kind) {
-          throw new ToolInputError(
-            `Match key "${key}" expects ${field.kind} values.`
-          );
-        }
-        if (field.enum && typeof entry === "string" && !field.enum.includes(entry)) {
-          throw new ToolInputError(
-            `Match key "${key}" does not allow value "${entry}".`
-          );
-        }
-      }
-      normalized[key] = [...new Set(value)];
-      continue;
-    }
-    if (typeof value !== field.kind) {
-      throw new ToolInputError(
-        `Match key "${key}" expects a ${field.kind} value.`
-      );
-    }
-    if (field.enum && typeof value === "string" && !field.enum.includes(value)) {
-      throw new ToolInputError(
-        `Match key "${key}" does not allow value "${value}".`
-      );
-    }
-    normalized[key] = value;
-  }
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-function normalizeEventIdentifier(catalog, namespace, identifier) {
-  return normalizeResourceEventIdentifier(catalog[namespace], identifier);
-}
-
-// src/chat/sandbox/snapshot/events.ts
-var WORKSPACE_SNAPSHOT_NAMESPACE = CORE_RESOURCE_EVENT_NAMESPACE;
-var WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
-var WORKSPACE_SNAPSHOT_READY_EVENT = "workspace_snapshot.ready";
-var WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
-function workspaceSnapshotResourceEvents() {
-  return {
-    resourceTypes: [
-      {
-        type: WORKSPACE_SNAPSHOT_RESOURCE_TYPE,
-        supportedEvents: [
-          WORKSPACE_SNAPSHOT_READY_EVENT,
-          WORKSPACE_SNAPSHOT_FAILED_EVENT
-        ],
-        // switchWorkspace already creates the temporary subscription.
-        suggestedEvents: [],
-        guidance: {
-          [WORKSPACE_SNAPSHOT_READY_EVENT]: "Call switchWorkspace again with the same Workspace name. Do not create another watch when switchWorkspace already returned a subscription.",
-          [WORKSPACE_SNAPSHOT_FAILED_EVENT]: "Report the snapshot failure. Do not keep waiting for this Workspace unless the user asks to retry."
-        }
-      }
-    ]
-  };
-}
-function workspaceSnapshotWatch(input) {
-  return {
-    identifier: input.workspaceId,
-    label: `Workspace ${input.workspaceName} snapshot`,
-    namespace: WORKSPACE_SNAPSHOT_NAMESPACE,
-    supportedEvents: [
-      WORKSPACE_SNAPSHOT_READY_EVENT,
-      WORKSPACE_SNAPSHOT_FAILED_EVENT
-    ],
-    suggestedEvents: [],
-    type: WORKSPACE_SNAPSHOT_RESOURCE_TYPE
-  };
-}
-function workspaceSnapshotFinishedEvent(input) {
-  const occurredAtMs = input.occurredAtMs ?? Date.now();
-  const eventType = input.status === "ready" ? WORKSPACE_SNAPSHOT_READY_EVENT : WORKSPACE_SNAPSHOT_FAILED_EVENT;
-  const trustedSummary = input.status === "ready" ? "Workspace snapshot is ready." : "Workspace snapshot build failed.";
-  const event = {
-    eventKey: `${WORKSPACE_SNAPSHOT_NAMESPACE}:${input.workspaceId}:${input.resultId}:${input.status}`,
-    eventType,
-    identifier: input.workspaceId,
-    namespace: WORKSPACE_SNAPSHOT_NAMESPACE,
-    occurredAtMs,
-    terminal: true,
-    trustedSummary,
-    data: {
-      workspaceId: input.workspaceId,
-      status: input.status
-    }
-  };
-  if (input.status === "failed" && input.error) {
-    event.untrustedText = input.error;
-  }
-  return event;
-}
-
-// src/chat/resource-events/runtime-catalog.ts
-function getResourceEventCatalog() {
-  const catalog = {
-    [CORE_RESOURCE_EVENT_NAMESPACE]: workspaceSnapshotResourceEvents()
-  };
-  for (const plugin of getPlugins()) {
-    const registration = plugin.resourceEvents;
-    if (!registration || registration.isEnabled?.() === false) {
-      continue;
-    }
-    if (plugin.manifest.name === CORE_RESOURCE_EVENT_NAMESPACE) {
-      throw new Error(
-        `Plugin "${CORE_RESOURCE_EVENT_NAMESPACE}" cannot register resource events; that namespace is reserved for core Workspace snapshots`
-      );
-    }
-    catalog[plugin.manifest.name] = registration;
-  }
-  return catalog;
-}
-
-// 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),
-  match: z4.record(z4.string(), z4.unknown()).optional(),
-  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) {
-  const plugins = pluginResourceEventCatalog(catalog);
-  return z4.object({
-    namespace: eventNamespaceSchema(plugins),
-    identifier: z4.string().trim().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
-    resourceType: registeredResourceTypeSchema(plugins),
-    label: z4.string().trim().min(1).max(500),
-    events: z4.array(registeredEventTypeSchema(plugins)).min(1),
-    match: registeredResourceEventMatchSchema()
-  }).strict();
-}
-function requireSupportedEventTaskTrigger(catalog, trigger) {
-  const plugins = pluginResourceEventCatalog(catalog);
-  for (const eventType of trigger.events) {
-    if (!pluginSupportsEvent(
-      plugins,
-      trigger.namespace,
-      trigger.resourceType,
-      eventType
-    )) {
-      throw new ToolInputError(
-        `Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`
-      );
-    }
-  }
-  return requireSupportedResourceEventMatch(plugins, {
-    match: trigger.match,
-    namespace: trigger.namespace,
-    resourceType: trigger.resourceType
-  });
-}
-function requireEventTaskSlackContext(context) {
-  if (context.source.kind !== "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;
-}
-function eventTaskIsWritableFrom(task, destination) {
-  if (task.destination.teamId !== destination.teamId) {
-    return false;
-  }
-  return task.destination.channelId === destination.channelId || task.destinationVisibility === "public";
-}
-async function writableEventTask(context, id) {
-  const { destination } = requireEventTaskSlackContext(context);
-  const task = await getEventTask(getDb(), id);
-  if (!task || task.status === "deleted" || !eventTaskIsWritableFrom(task, destination)) {
-    throw new ToolInputError("Event task was not found.");
-  }
-  return task;
-}
-function eventTaskTriggerAvailable(task, catalog) {
-  const registration = pluginResourceEventCatalog(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,
-    ...task.trigger.match ? { match: task.trigger.match } : void 0,
-    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 {
-  actorUserIdSchema as actorUserIdSchema2,
-  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: actorUserIdSchema2,
-  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(dcramer): Remove paused decoding and SQL list filtering after
-  // v0.129.x workers are unsupported and cannot overlap an upgrade.
-  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 } : void 0
-    };
-  }
-  return {
-    ...task,
-    creatorIdentityId,
-    status,
-    ...title ? { title } : void 0
-  };
-}
-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 } : void 0
-  };
-}
-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(dcramer): Stop writing this column after v0.127.x runtimes are
-    // unsupported and no supported runtime reads it.
-    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")
-      )
-    );
-  }
-  if (task.status === "deleted" && current?.status !== "deleted") {
-    await skipPendingRunsForDeletedTask(db, task);
-  }
-  await upsertScheduledTask(db, task);
-}
-async function skipPendingRunsForDeletedTask(db, task) {
-  const errorMessage = `Scheduled task ${task.id} was deleted before the run started.`;
-  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(
-    and3(
-      eq2(juniorSchedulerRuns.taskId, task.id),
-      eq2(juniorSchedulerRuns.status, "pending")
-    )
-  );
-  for (const row of rows) {
-    const parsed = scheduledRunSchema.safeParse(row.record);
-    if (!parsed.success || parsed.data.status !== "pending") continue;
-    const next = scheduledRunSchema.parse({
-      ...parsed.data,
-      completedAtMs: task.updatedAtMs,
-      errorMessage,
-      status: "skipped"
-    });
-    await db.update(juniorSchedulerRuns).set({
-      record: next,
-      status: next.status
-    }).where(
-      and3(
-        eq2(juniorSchedulerRuns.id, next.id),
-        eq2(juniorSchedulerRuns.status, "pending")
-      )
-    );
-  }
-}
-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, lte as lte2, or as or2 } from "drizzle-orm";
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var ATTACHMENT_GC_BATCH_LIMIT = 200;
-var ATTACHMENT_RETENTION_MS = 30 * DAY_MS;
-function attachmentDigest(file) {
-  return createHash("sha256").update(file.data).digest("hex");
-}
-function attachmentId(args) {
-  const identity = [
-    args.conversationId,
-    args.storageProvider,
-    args.sha256,
-    args.filename,
-    args.contentType
-  ];
-  if (args.source) {
-    identity.push(args.source.provider, args.source.id);
-  }
-  return createHash("sha256").update(identity.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,
-    source: args.source,
-    storageProvider: 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,
-    providerId: juniorAttachments.providerId,
-    storageProvider: juniorAttachments.storageProvider,
-    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.source?.provider ?? null) || existing.providerId !== (args.source?.id ?? null) || existing.storageProvider !== 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,
-      storageProvider: args.storage.provider,
-      storageKey,
-      provider: args.source?.provider,
-      providerId: args.source?.id,
-      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,
-    storageProvider: juniorAttachments.storageProvider,
-    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,
-    storageKey: row.storageKey,
-    storageProvider: row.storageProvider
-  };
-}
-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 } : void 0,
-        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) {
-  const expiresBefore = new Date(args.nowMs - ATTACHMENT_RETENTION_MS);
-  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.storageProvider, args.storage.provider),
-      or2(
-        lte2(juniorAttachments.createdAt, expiresBefore),
-        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(
-        lte2(juniorAttachments.createdAt, expiresBefore),
-        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,
-  hasResourceEventCatalogEntries,
-  hasPluginResourceEventCatalogEntries,
-  eventNamespaceSchema,
-  registeredEventTypeSchema,
-  registeredResourceTypeSchema,
-  pluginSupportsEvent,
-  resourceEventGuidance,
-  registeredResourceEventMatchSchema,
-  requireSupportedResourceEventMatch,
-  normalizeEventIdentifier,
-  WORKSPACE_SNAPSHOT_READY_EVENT,
-  WORKSPACE_SNAPSHOT_FAILED_EVENT,
-  workspaceSnapshotWatch,
-  workspaceSnapshotFinishedEvent,
-  getResourceEventCatalog,
-  getEventTask,
-  createEventTask,
-  saveEventTask,
-  deleteEventTask,
-  listEventTasksForTeam,
-  eventTaskBelongsToUser,
-  listEventTasksCreatedBy,
-  listDeletedEventTasksCreatedBy,
-  listPublicEventTasksForTeams,
-  collectEventTaskMatchKeys,
-  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,
-  storeAttachment,
-  readLiveAttachment,
-  storeAttachments,
-  requestAttachmentDeletion,
-  collectAttachmentGarbage,
-  incrementStat,
-  readStats
-};