@tool-bridge/server 0.1.1 → 0.3.0

package/dist/sentry-HUQTGXOV.js

@@ -0,0 +1,1139 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/sentry/api.ts
+var SERVICE = "sentry";
+var API_BASE = "https://sentry.io/api/0/";
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function nullableStr(value) {
+  return typeof value === "string" ? value : null;
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function pickStr(...values) {
+  for (const value of values) {
+    if (nonEmpty(value)) return value;
+  }
+  return void 0;
+}
+function nullableInt(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) ? parsed : null;
+}
+function bool(value) {
+  return value === true;
+}
+function strArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function nullableStrArray(value) {
+  return value === null ? null : strArray(value);
+}
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, child]) => child !== void 0));
+}
+function expectRecord(value, label) {
+  const body = record(value);
+  if (body === void 0) throw new TBError("unavailable", `Sentry ${label} \u54CD\u5E94\u5F62\u72B6\u4E0D\u7B26`, { retryable: true });
+  return body;
+}
+function expectArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new TBError("unavailable", `Sentry ${label} \u54CD\u5E94\u4E0D\u662F\u6570\u7EC4`, { retryable: true });
+  }
+  return value;
+}
+function oneZero(value) {
+  return value === void 0 ? void 0 : value ? "1" : "0";
+}
+function joinClauses(...clauses) {
+  const kept = clauses.filter((clause) => nonEmpty(clause));
+  return kept.length > 0 ? kept.join(" ") : void 0;
+}
+function buildUrl(path, query) {
+  const url = new URL(path, API_BASE);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, String(item));
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function errorMessage(payload, status) {
+  const body = record(payload);
+  const nested = str(record(body?.detail)?.message);
+  return pickStr(body?.error_description, body?.detail, body?.error, body?.message) ?? (nonEmpty(nested) ? nested : void 0) ?? `Sentry \u8FD4\u56DE HTTP ${status}`;
+}
+async function readJson(response) {
+  if (!(response.headers.get("content-type") ?? "").includes("application/json")) return null;
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function request(ctx, path, options = {}) {
+  const token = requireApiKey(ctx, SERVICE);
+  const headers = {
+    accept: "application/json",
+    authorization: `Bearer ${token}`
+  };
+  if (options.body !== void 0) headers["content-type"] = "application/json";
+  let response;
+  try {
+    response = await guardedFetch(buildUrl(path, options.query), {
+      method: options.method ?? "GET",
+      headers,
+      ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) }
+    });
+  } catch (error) {
+    if (error instanceof TBError) throw error;
+    throw upstreamError(502, `Sentry \u8BF7\u6C42\u5931\u8D25:${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  const payload = await readJson(response);
+  if (!response.ok) throw upstreamError(response.status, errorMessage(payload, response.status));
+  return { payload, headers: response.headers };
+}
+function splitLinkHeader(value) {
+  const entries = [];
+  let current = "";
+  let inQuotes = false;
+  let inAngles = false;
+  for (const char of value) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (!inQuotes) {
+      if (char === "<") inAngles = true;
+      else if (char === ">") inAngles = false;
+      else if (char === "," && !inAngles) {
+        if (current.trim() !== "") entries.push(current.trim());
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.trim() !== "") entries.push(current.trim());
+  return entries;
+}
+function linkCursor(entry) {
+  const direct = /\bcursor="([^"]*)"/.exec(entry)?.[1];
+  if (nonEmpty(direct)) return direct;
+  const urlString = /<([^>]*)>/.exec(entry)?.[1];
+  if (!nonEmpty(urlString)) return null;
+  try {
+    return new URL(urlString).searchParams.get("cursor");
+  } catch {
+    return null;
+  }
+}
+function cursors(headers) {
+  const result = { nextCursor: null, previousCursor: null };
+  const header = headers.get("link");
+  if (!nonEmpty(header)) return result;
+  for (const entry of splitLinkHeader(header)) {
+    const rel = /\brel="([^"]+)"/.exec(entry)?.[1];
+    if (rel !== "next" && rel !== "previous") continue;
+    if (/\bresults="([^"]+)"/.exec(entry)?.[1] === "false") continue;
+    const cursor = linkCursor(entry);
+    if (cursor === null) continue;
+    if (rel === "next") result.nextCursor = cursor;
+    else result.previousCursor = cursor;
+  }
+  return result;
+}
+function normalizeSetupDialog(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return { url: nullableStr(body.url), width: nullableInt(body.width), height: nullableInt(body.height) };
+}
+function normalizeProviderMetadata(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return {
+    noun: nullableStr(body.noun),
+    author: nullableStr(body.author),
+    description: nullableStr(body.description),
+    // Sentry 同一字段在不同端点上 camelCase 与 snake_case 混用,两种都收。
+    issueUrl: nullableStr(body.issueUrl ?? body.issue_url),
+    sourceUrl: nullableStr(body.sourceUrl ?? body.source_url),
+    aspects: record(body.aspects) ?? null,
+    features: arrayValue(body.features)
+  };
+}
+function normalizeIntegrationProvider(value) {
+  const body = expectRecord(value, "integration provider");
+  return {
+    key: str(body.key) ?? "",
+    slug: str(body.slug) ?? "",
+    name: str(body.name) ?? "",
+    canAdd: bool(body.canAdd),
+    canDisable: bool(body.canDisable),
+    features: strArray(body.features),
+    aspects: record(body.aspects) ?? {},
+    metadata: normalizeProviderMetadata(body.metadata),
+    setupDialog: normalizeSetupDialog(body.setupDialog)
+  };
+}
+function normalizeOrganizationIntegration(value) {
+  const body = expectRecord(value, "integration");
+  return {
+    id: str(body.id) ?? "",
+    name: str(body.name) ?? "",
+    icon: nullableStr(body.icon),
+    domainName: nullableStr(body.domainName),
+    accountType: nullableStr(body.accountType),
+    scopes: nullableStrArray(body.scopes),
+    status: nullableStr(body.status),
+    provider: normalizeIntegrationProvider(body.provider),
+    configOrganization: arrayValue(body.configOrganization),
+    configData: record(body.configData ?? body.config_data) ?? {},
+    externalId: nullableStr(body.externalId),
+    organizationId: nullableInt(body.organizationId),
+    organizationIntegrationStatus: nullableStr(body.organizationIntegrationStatus),
+    gracePeriodEnd: nullableStr(body.gracePeriodEnd)
+  };
+}
+function normalizeSentryAppOwner(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return { id: nullableInt(body.id), slug: nullableStr(body.slug) };
+}
+function normalizeSentryAppAvatars(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const body = record(item);
+    if (body === void 0) return [];
+    return [{
+      avatarType: str(body.avatarType) ?? "",
+      avatarUuid: str(body.avatarUuid) ?? "",
+      avatarUrl: str(body.avatarUrl) ?? "",
+      color: bool(body.color),
+      photoType: str(body.photoType) ?? ""
+    }];
+  });
+}
+function normalizeSentryApp(value) {
+  const body = expectRecord(value, "app");
+  return {
+    name: str(body.name) ?? "",
+    slug: str(body.slug) ?? "",
+    uuid: str(body.uuid) ?? "",
+    owner: normalizeSentryAppOwner(body.owner),
+    author: nullableStr(body.author),
+    events: strArray(body.events),
+    schema: body.schema ?? null,
+    scopes: strArray(body.scopes),
+    status: str(body.status) ?? "",
+    avatars: normalizeSentryAppAvatars(body.avatars),
+    clientId: nullableStr(body.clientId),
+    metadata: body.metadata ?? null,
+    overview: nullableStr(body.overview),
+    popularity: nullableInt(body.popularity),
+    webhookUrl: nullableStr(body.webhookUrl),
+    featureData: arrayValue(body.featureData),
+    isAlertable: bool(body.isAlertable),
+    redirectUrl: nullableStr(body.redirectUrl),
+    // 只透出"有没有",**不透出 clientSecret 本身** —— Sentry App 的 client secret
+    // 是另一套凭证,让它经工具出参流到 agent 的上下文里就是一次凭证外泄。
+    hasClientSecret: nonEmpty(body.clientSecret),
+    verifyInstall: bool(body.verifyInstall),
+    allowedOrigins: strArray(body.allowedOrigins)
+  };
+}
+function normalizeTeam(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return { id: nullableStr(body.id), slug: nullableStr(body.slug), name: nullableStr(body.name) };
+}
+function normalizeTeams(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const team = normalizeTeam(item);
+    return team === null ? [] : [team];
+  });
+}
+function normalizeProject(value) {
+  const body = expectRecord(value, "project");
+  return {
+    id: str(body.id) ?? "",
+    slug: str(body.slug) ?? "",
+    name: str(body.name) ?? "",
+    platform: nullableStr(body.platform),
+    status: nullableStr(body.status),
+    dateCreated: nullableStr(body.dateCreated),
+    isBookmarked: bool(body.isBookmarked),
+    isMember: bool(body.isMember),
+    hasAccess: bool(body.hasAccess),
+    features: strArray(body.features),
+    environments: strArray(body.environments),
+    team: normalizeTeam(body.team),
+    teams: normalizeTeams(body.teams)
+  };
+}
+function normalizeProjectSummary(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return {
+    id: str(body.id) ?? "",
+    slug: str(body.slug) ?? "",
+    name: str(body.name) ?? "",
+    platform: nullableStr(body.platform)
+  };
+}
+function normalizeIssueActor(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return {
+    id: nullableStr(body.id),
+    type: nullableStr(body.type),
+    name: nullableStr(body.name),
+    email: nullableStr(body.email),
+    username: nullableStr(body.username)
+  };
+}
+function normalizeIssueStatusDetails(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  const inNextRelease = body.inNextRelease ?? body.in_next_release;
+  return {
+    inRelease: nullableStr(body.inRelease ?? body.in_release),
+    inCommit: nullableStr(body.inCommit ?? body.in_commit),
+    inNextRelease: typeof inNextRelease === "boolean" ? inNextRelease : null
+  };
+}
+function normalizeIssueTags(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const body = record(item);
+    if (body === void 0 || !nonEmpty(body.key)) return [];
+    return [{ key: body.key, name: nullableStr(body.name), value: nullableStr(body.value) }];
+  });
+}
+function normalizeIssue(value) {
+  const body = expectRecord(value, "issue");
+  return {
+    id: str(body.id) ?? "",
+    shortId: nullableStr(body.shortId),
+    title: nullableStr(body.title),
+    culprit: nullableStr(body.culprit),
+    level: nullableStr(body.level),
+    status: nullableStr(body.status),
+    // `count` 上游就是**字符串**(Sentry 回的是 "42"),别顺手改成数字。
+    count: nullableStr(body.count),
+    userCount: nullableInt(body.userCount),
+    firstSeen: nullableStr(body.firstSeen),
+    lastSeen: nullableStr(body.lastSeen),
+    permalink: nullableStr(body.permalink),
+    logger: nullableStr(body.logger),
+    isBookmarked: bool(body.isBookmarked),
+    isSubscribed: bool(body.isSubscribed),
+    hasSeen: bool(body.hasSeen),
+    isPublic: bool(body.isPublic),
+    project: normalizeProjectSummary(body.project),
+    assignedTo: normalizeIssueActor(body.assignedTo),
+    statusDetails: normalizeIssueStatusDetails(body.statusDetails),
+    metadata: body.metadata ?? null,
+    stats: body.stats ?? null,
+    tags: normalizeIssueTags(body.tags)
+  };
+}
+function normalizeEventUser(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return {
+    id: nullableStr(body.id),
+    email: nullableStr(body.email),
+    username: nullableStr(body.username),
+    ipAddress: nullableStr(body.ipAddress ?? body.ip_address ?? body.ip),
+    name: nullableStr(body.name)
+  };
+}
+function normalizeEventTags(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const body = record(item);
+    if (body === void 0 || !nonEmpty(body.key) || !nonEmpty(body.value)) return [];
+    return [{ key: body.key, value: body.value }];
+  });
+}
+function normalizeIssueEvent(value) {
+  const body = expectRecord(value, "issue event");
+  return {
+    // Sentry 的事件 id 在列表与详情上分别叫 `id` 与 `eventID`,两种都收。
+    id: str(body.id) ?? str(body.eventID) ?? "",
+    eventId: nullableStr(body.eventID ?? body.eventId),
+    issueId: nullableStr(body.groupID ?? body.groupId),
+    title: nullableStr(body.title),
+    message: nullableStr(body.message),
+    platform: nullableStr(body.platform),
+    dateCreated: nullableStr(body.dateCreated),
+    user: normalizeEventUser(body.user),
+    tags: normalizeEventTags(body.tags)
+  };
+}
+function normalizeReleaseProjects(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const body = record(item);
+    if (body === void 0) return [];
+    return [{ id: nullableInt(body.id), slug: nullableStr(body.slug), name: nullableStr(body.name) }];
+  });
+}
+function normalizeRelease(value) {
+  const body = expectRecord(value, "release");
+  return {
+    version: str(body.version) ?? "",
+    shortVersion: nullableStr(body.shortVersion),
+    status: nullableStr(body.status),
+    dateCreated: nullableStr(body.dateCreated),
+    dateReleased: nullableStr(body.dateReleased),
+    ref: nullableStr(body.ref),
+    url: nullableStr(body.url),
+    newGroups: nullableInt(body.newGroups),
+    projects: normalizeReleaseProjects(body.projects),
+    lastCommit: body.lastCommit ?? body.last_commit ?? null,
+    lastDeploy: body.lastDeploy ?? body.last_deploy ?? null,
+    healthData: body.healthData ?? body.health_data ?? null,
+    stats: body.stats ?? null
+  };
+}
+function normalizeHealthGroups(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const body = record(item);
+    if (body === void 0) return [];
+    return [{ by: record(body.by) ?? {}, totals: record(body.totals) ?? {}, series: record(body.series) ?? null }];
+  });
+}
+function normalizeReplayUser(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return {
+    id: nullableStr(body.id),
+    email: nullableStr(body.email),
+    username: nullableStr(body.username),
+    ip: nullableStr(body.ip ?? body.ipAddress ?? body.ip_address)
+  };
+}
+function normalizeNamedValue(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return { name: nullableStr(body.name), version: nullableStr(body.version) };
+}
+function normalizeReplayReleases(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (typeof item === "string") return [item];
+    const version = str(record(item)?.version);
+    return version === void 0 ? [] : [version];
+  });
+}
+function normalizeReplay(value) {
+  const body = expectRecord(value, "replay");
+  return {
+    id: str(body.id) ?? "",
+    projectId: nullableInt(body.projectId ?? body.project_id),
+    environment: nullableStr(body.environment),
+    platform: nullableStr(body.platform),
+    startedAt: nullableStr(body.startedAt ?? body.started_at),
+    finishedAt: nullableStr(body.finishedAt ?? body.finished_at),
+    duration: nullableInt(body.duration),
+    countErrors: nullableInt(body.countErrors ?? body.count_errors),
+    countRageClicks: nullableInt(body.countRageClicks ?? body.count_rage_clicks),
+    countDeadClicks: nullableInt(body.countDeadClicks ?? body.count_dead_clicks),
+    countSegments: nullableInt(body.countSegments ?? body.count_segments),
+    user: normalizeReplayUser(body.user),
+    browser: normalizeNamedValue(body.browser),
+    os: normalizeNamedValue(body.os),
+    device: normalizeNamedValue(body.device),
+    releases: normalizeReplayReleases(body.releases)
+  };
+}
+function normalizeCreatedBy(value) {
+  if (typeof value === "string") return value;
+  const body = record(value);
+  if (body === void 0) return null;
+  return nullableStr(body.id ?? body.email ?? body.username);
+}
+function normalizeAlertTrigger(value) {
+  const body = record(value);
+  if (body === void 0) return null;
+  return {
+    id: nullableStr(body.id),
+    logicType: nullableStr(body.logicType),
+    actions: body.actions ?? null,
+    conditions: body.conditions ?? null,
+    organizationId: nullableStr(body.organizationId ?? body.organization_id)
+  };
+}
+function normalizeAlertActionFilters(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const body = record(item);
+    if (body === void 0) return [];
+    return [{
+      id: nullableStr(body.id),
+      actions: body.actions ?? null,
+      logicType: nullableStr(body.logicType),
+      conditions: body.conditions ?? null,
+      organizationId: nullableStr(body.organizationId ?? body.organization_id)
+    }];
+  });
+}
+function normalizeAlert(value) {
+  const body = expectRecord(value, "alert");
+  return {
+    id: str(body.id) ?? "",
+    name: str(body.name) ?? "",
+    organizationId: nullableStr(body.organizationId ?? body.organization_id),
+    enabled: bool(body.enabled),
+    createdBy: normalizeCreatedBy(body.createdBy),
+    dateCreated: nullableStr(body.dateCreated),
+    dateUpdated: nullableStr(body.dateUpdated),
+    environment: nullableStr(body.environment),
+    lastTriggered: nullableStr(body.lastTriggered),
+    detectorIds: strArray(body.detectorIds),
+    config: record(body.config) ?? {},
+    triggers: normalizeAlertTrigger(body.triggers),
+    actionFilters: normalizeAlertActionFilters(body.actionFilters)
+  };
+}
+function unwrapWorkflowList(payload) {
+  if (Array.isArray(payload)) return payload;
+  const body = record(payload);
+  if (body === void 0 || !Array.isArray(body.data)) {
+    throw new TBError("unavailable", "Sentry alerts \u54CD\u5E94\u5F62\u72B6\u4E0D\u7B26", { retryable: true });
+  }
+  return body.data;
+}
+function unwrapWorkflowItem(payload) {
+  const body = record(payload);
+  return body !== void 0 && "data" in body ? body.data : payload;
+}
+function seg(value) {
+  return encodeURIComponent(value);
+}
+async function listOrganizationIntegrations(input, ctx) {
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/integrations/`, {
+    query: compact({
+      providerKey: input.providerKey,
+      includeConfig: input.includeConfig,
+      features: input.features
+    })
+  });
+  return { integrations: expectArray(payload, "integrations").map(normalizeOrganizationIntegration) };
+}
+async function getOrganizationIntegration(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/integrations/${seg(input.integrationId)}/`;
+  const { payload } = await request(ctx, path);
+  return { integration: normalizeOrganizationIntegration(payload) };
+}
+async function getOrganizationIntegrationConfig(input, ctx) {
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/config/integrations/`, {
+    query: { providerKey: input.providerKey }
+  });
+  const body = expectRecord(payload, "integration config");
+  if (!Array.isArray(body.providers)) {
+    throw new TBError("unavailable", "Sentry integration config \u54CD\u5E94\u7F3A providers", { retryable: true });
+  }
+  return { providers: body.providers.map(normalizeIntegrationProvider) };
+}
+async function listOrganizationSentryApps(input, ctx) {
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/sentry-apps/`);
+  return { sentryApps: expectArray(payload, "apps").map(normalizeSentryApp) };
+}
+async function getSentryApp(input, ctx) {
+  const { payload } = await request(ctx, `sentry-apps/${seg(input.sentryAppIdOrSlug)}/`);
+  return { sentryApp: normalizeSentryApp(payload) };
+}
+async function listOrganizationProjects(input, ctx) {
+  const { payload, headers } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/projects/`, {
+    query: { cursor: input.cursor }
+  });
+  return {
+    projects: expectArray(payload, "projects").map(normalizeProject),
+    ...cursors(headers)
+  };
+}
+async function getProject(input, ctx) {
+  const { payload } = await request(ctx, `projects/${seg(input.organizationIdOrSlug)}/${seg(input.projectIdOrSlug)}/`);
+  return { project: normalizeProject(payload) };
+}
+async function listOrganizationIssues(input, ctx) {
+  const { payload, headers } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/issues/`, {
+    query: {
+      query: input.query,
+      sort: input.sort,
+      limit: input.limit,
+      start: input.start,
+      end: input.end,
+      cursor: input.cursor,
+      expand: input.expand,
+      collapse: input.collapse,
+      // 入参名是复数 `environments` / `projectIds`,线上是单数 `environment` / `project`。
+      environment: input.environments,
+      project: input.projectIds,
+      statsPeriod: input.statsPeriod,
+      // Sentry 这个参数只认 1/0,给 true/false 会被当成"没传"。
+      shortIdLookup: oneZero(input.shortIdLookup),
+      groupStatsPeriod: input.groupStatsPeriod,
+      viewId: input.viewId
+    }
+  });
+  return {
+    issues: expectArray(payload, "issues").map(normalizeIssue),
+    ...cursors(headers)
+  };
+}
+async function getIssue(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/issues/${seg(input.issueId)}/`;
+  const { payload } = await request(ctx, path);
+  return { issue: normalizeIssue(payload) };
+}
+async function getIssueEvent(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/issues/${seg(input.issueId)}/events/${seg(input.eventId)}/`;
+  const { payload } = await request(ctx, path, { query: { environment: input.environments } });
+  return { event: normalizeIssueEvent(payload) };
+}
+async function listIssueEvents(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/issues/${seg(input.issueId)}/events/`;
+  const { payload } = await request(ctx, path, {
+    query: {
+      full: input.full,
+      sample: input.sample,
+      query: input.query,
+      start: input.start,
+      end: input.end,
+      environment: input.environments,
+      statsPeriod: input.statsPeriod
+    }
+  });
+  return { events: expectArray(payload, "issue events").map(normalizeIssueEvent) };
+}
+async function updateIssue(input, ctx) {
+  const details = input.statusDetails === void 0 ? void 0 : compact({ ...input.statusDetails });
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/issues/${seg(input.issueId)}/`, {
+    method: "PUT",
+    body: compact({
+      status: input.status,
+      hasSeen: input.hasSeen,
+      isPublic: input.isPublic,
+      // 空串是**取消指派**的正规写法(不是"没给值"),故这里不能用 `text()` 过滤掉它。
+      assignedTo: input.assignedTo,
+      isBookmarked: input.isBookmarked,
+      isSubscribed: input.isSubscribed,
+      statusDetails: details
+    })
+  });
+  return { issue: normalizeIssue(payload) };
+}
+async function listOrganizationReleases(input, ctx) {
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/releases/`, {
+    query: { query: input.query }
+  });
+  return { releases: expectArray(payload, "releases").map(normalizeRelease) };
+}
+async function getOrganizationRelease(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/releases/${seg(input.version)}/`;
+  const { payload } = await request(ctx, path, {
+    query: compact({
+      sort: input.sort,
+      query: input.query,
+      health: input.health,
+      status: input.status,
+      // 入参叫 projectId,线上参数名是 project。
+      project: input.projectId,
+      adoptionStages: input.adoptionStages,
+      healthStatsPeriod: input.healthStatsPeriod,
+      summaryStatsPeriod: input.summaryStatsPeriod
+    })
+  });
+  return { release: normalizeRelease(payload) };
+}
+async function getReleaseHealthStats(input, ctx) {
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/sessions/`, {
+    query: {
+      field: input.fields,
+      groupBy: input.groupBy,
+      query: joinClauses(`release:${input.version}`, input.query),
+      start: input.start,
+      end: input.end,
+      environment: input.environments,
+      project: input.projectIds,
+      interval: input.interval,
+      statsPeriod: input.statsPeriod,
+      includeSeries: input.includeSeries,
+      includeTotals: input.includeTotals,
+      // 这一个是 snake_case,同一个端点上与 camelCase 参数混着用。
+      per_page: input.perPage,
+      orderBy: input.orderBy
+    }
+  });
+  const body = expectRecord(payload, "release health stats");
+  return {
+    groups: normalizeHealthGroups(body.groups),
+    intervals: strArray(body.intervals),
+    start: nullableStr(body.start),
+    end: nullableStr(body.end)
+  };
+}
+async function listOrganizationReplays(input, ctx) {
+  const { payload, headers } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/replays/`, {
+    query: {
+      start: input.start,
+      end: input.end,
+      sort: input.sort,
+      field: input.field,
+      query: input.query,
+      cursor: input.cursor,
+      project: input.projectIds,
+      per_page: input.perPage,
+      environment: input.environment,
+      statsPeriod: input.statsPeriod
+    }
+  });
+  return {
+    replays: expectArray(payload, "replays").map(normalizeReplay),
+    ...cursors(headers)
+  };
+}
+async function getReplay(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/replays/${seg(input.replayId)}/`;
+  const { payload, headers } = await request(ctx, path, {
+    query: {
+      start: input.start,
+      end: input.end,
+      sort: input.sort,
+      field: input.field,
+      query: input.query,
+      cursor: input.cursor,
+      project: input.projectIds,
+      per_page: input.perPage,
+      environment: input.environment,
+      statsPeriod: input.statsPeriod
+    }
+  });
+  return { replay: normalizeReplay(payload), ...cursors(headers) };
+}
+async function listAlerts(input, ctx) {
+  const { payload } = await request(ctx, `organizations/${seg(input.organizationIdOrSlug)}/workflows/`, {
+    query: {
+      // 入参叫 ids,线上参数名是单数 id(可重复)。
+      id: input.ids,
+      query: input.query,
+      sortBy: input.sortBy,
+      project: input.projectIds
+    }
+  });
+  return { alerts: unwrapWorkflowList(payload).map(normalizeAlert) };
+}
+async function getAlert(input, ctx) {
+  const path = `organizations/${seg(input.organizationIdOrSlug)}/workflows/${seg(input.alertId)}/`;
+  const { payload } = await request(ctx, path);
+  return { alert: normalizeAlert(unwrapWorkflowItem(payload)) };
+}
+
+// ../plugins/src/sentry/schema.ts
+var listOrganizationIntegrationsInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The Sentry organization id or slug whose installed integrations should be listed."),
+  providerKey: external_exports.string().min(1).describe("Optional provider key filter such as slack, github, or jira.").optional(),
+  includeConfig: external_exports.boolean().describe("Whether to ask Sentry to include expanded third-party configuration details.").optional(),
+  features: external_exports.array(external_exports.string().min(1)).describe("Optional provider feature filters such as alert-rule or issue-sync.").optional()
+}).describe("The input payload for listing installed Sentry integrations.");
+var listOrganizationIntegrationsOutput = external_exports.strictObject({
+  integrations: external_exports.array(external_exports.looseObject({}).describe("An installed integration within a Sentry organization.")).describe("The installed integrations returned for the organization.")
+}).describe("Action output.");
+var getOrganizationIntegrationInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The Sentry organization id or slug that owns the integration."),
+  integrationId: external_exports.string().min(1).describe("The installed integration id to retrieve.")
+}).describe("The input payload for retrieving an installed Sentry integration.");
+var getOrganizationIntegrationOutput = external_exports.strictObject({
+  integration: external_exports.looseObject({}).describe("An installed integration within a Sentry organization.")
+}).describe("Action output.");
+var getOrganizationIntegrationConfigInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The Sentry organization id or slug whose integration config should be retrieved."),
+  providerKey: external_exports.string().min(1).describe("Optional provider key filter such as slack, github, or jira.").optional()
+}).describe("The input payload for retrieving Sentry integration provider config.");
+var getOrganizationIntegrationConfigOutput = external_exports.strictObject({
+  providers: external_exports.array(external_exports.looseObject({}).describe("A Sentry integration provider summary.")).describe("The integration provider configs returned by Sentry.")
+}).describe("Action output.");
+var listOrganizationSentryAppsInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The Sentry organization id or slug whose custom Sentry Apps should be listed.")
+}).describe("The input payload for listing organization-owned Sentry Apps.");
+var listOrganizationSentryAppsOutput = external_exports.strictObject({
+  sentryApps: external_exports.array(external_exports.looseObject({}).describe("A Sentry App with integration and OAuth settings details.")).describe("The custom Sentry Apps returned for the organization.")
+}).describe("Action output.");
+var getSentryAppInput = external_exports.strictObject({
+  sentryAppIdOrSlug: external_exports.string().min(1).describe("The Sentry App id or slug to retrieve from the global Sentry App registry.")
+}).describe("The input payload for retrieving a Sentry App.");
+var getSentryAppOutput = external_exports.strictObject({
+  sentryApp: external_exports.looseObject({}).describe("A Sentry App with integration and OAuth settings details.")
+}).describe("Action output.");
+var listOrganizationProjectsInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The Sentry organization id or slug whose projects should be listed."),
+  cursor: external_exports.string().min(1).describe("The opaque Sentry pagination cursor for the next or previous page.").optional()
+}).describe("The input payload for listing Sentry organization projects.");
+var listOrganizationProjectsOutput = external_exports.strictObject({
+  projects: external_exports.array(external_exports.looseObject({}).describe("A Sentry project returned by project list or detail endpoints.")).describe("The projects returned by Sentry."),
+  nextCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the next page, or null when there are no more results.").nullable(),
+  previousCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the previous page, or null when there are no earlier results.").nullable()
+}).describe("Action output.");
+var getProjectInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the project."),
+  projectIdOrSlug: external_exports.string().min(1).describe("The Sentry project id or slug to retrieve.")
+}).describe("The input payload for retrieving one Sentry project.");
+var getProjectOutput = external_exports.strictObject({
+  project: external_exports.looseObject({}).describe("A Sentry project returned by project list or detail endpoints.")
+}).describe("Action output.");
+var listOrganizationIssuesInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug whose issues should be listed."),
+  query: external_exports.string().describe("The Sentry issue search query string used to filter the results.").optional(),
+  sort: external_exports.string().describe("The issue sort order such as date, freq, inbox, new, trends, or user.").optional(),
+  limit: external_exports.int().min(1).max(100).describe("The maximum number of issues to return in one page.").optional(),
+  start: external_exports.string().describe("The inclusive ISO 8601 start time used to filter the issue results.").optional(),
+  end: external_exports.string().describe("The inclusive ISO 8601 end time used to filter the issue results.").optional(),
+  cursor: external_exports.string().describe("The opaque Sentry pagination cursor for the issue results.").optional(),
+  expand: external_exports.array(external_exports.string().min(1)).describe("Additional issue data keys that Sentry should expand in the response.").optional(),
+  collapse: external_exports.array(external_exports.string().min(1)).describe("Response sections that Sentry should collapse or omit from the payload.").optional(),
+  environments: external_exports.array(external_exports.string().min(1)).describe("The environment names used to filter issues.").optional(),
+  projectIds: external_exports.array(external_exports.int().describe("A numeric Sentry project id.")).describe("The numeric Sentry project ids used to filter issues.").optional(),
+  statsPeriod: external_exports.string().describe("The relative stats period such as 24h or 7d used for issue statistics.").optional(),
+  shortIdLookup: external_exports.boolean().describe("Whether Sentry should parse short issue ids inside the query string.").optional(),
+  groupStatsPeriod: external_exports.string().describe("The issue group statistics window such as auto, 24h, or 14d.").optional(),
+  viewId: external_exports.string().describe("The Sentry saved view id whose filters should be applied.").optional()
+}).describe("The input payload for listing Sentry organization issues.");
+var listOrganizationIssuesOutput = external_exports.strictObject({
+  issues: external_exports.array(external_exports.looseObject({}).describe("A Sentry issue summary or detail payload.")).describe("The issues returned by Sentry."),
+  nextCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the next page, or null when there are no more results.").nullable(),
+  previousCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the previous page, or null when there are no earlier results.").nullable()
+}).describe("Action output.");
+var getIssueInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the issue."),
+  issueId: external_exports.string().min(1).describe("The Sentry issue id or short id to retrieve.")
+}).describe("The input payload for retrieving one Sentry issue.");
+var getIssueOutput = external_exports.strictObject({
+  issue: external_exports.looseObject({}).describe("A Sentry issue summary or detail payload.")
+}).describe("Action output.");
+var getIssueEventInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the issue."),
+  issueId: external_exports.string().min(1).describe("The Sentry issue id whose event should be retrieved."),
+  eventId: external_exports.string().min(1).describe("The event id or selector such as latest, oldest, or recommended."),
+  environments: external_exports.array(external_exports.string().min(1)).describe("The environment names used to filter which issue event Sentry selects.").optional()
+}).describe("The input payload for retrieving one event from a Sentry issue.");
+var getIssueEventOutput = external_exports.strictObject({
+  event: external_exports.looseObject({}).describe("A normalized event associated with a Sentry issue.")
+}).describe("Action output.");
+var listIssueEventsInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the issue."),
+  issueId: external_exports.string().min(1).describe("The Sentry issue id whose events should be listed."),
+  full: external_exports.boolean().describe("Whether Sentry should return full event payloads instead of summaries.").optional(),
+  sample: external_exports.boolean().describe("Whether Sentry should return a deterministic sample of issue events.").optional(),
+  query: external_exports.string().describe("The Sentry event search query string used to filter issue events.").optional(),
+  start: external_exports.string().describe("The inclusive ISO 8601 start time used to filter issue events.").optional(),
+  end: external_exports.string().describe("The inclusive ISO 8601 end time used to filter issue events.").optional(),
+  environments: external_exports.array(external_exports.string().min(1)).describe("The environment names used to filter issue events.").optional(),
+  statsPeriod: external_exports.string().describe("The relative stats period such as 24h or 7d used to filter issue events.").optional()
+}).describe("The input payload for listing events attached to one Sentry issue.");
+var listIssueEventsOutput = external_exports.strictObject({
+  events: external_exports.array(external_exports.looseObject({}).describe("A normalized event associated with a Sentry issue.")).describe("The issue events returned by Sentry.")
+}).describe("Action output.");
+var updateIssueInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the issue."),
+  issueId: external_exports.string().min(1).describe("The Sentry issue id to update."),
+  status: external_exports.string().describe("The new issue status such as resolved, resolvedInNextRelease, unresolved, or ignored.").optional(),
+  hasSeen: external_exports.boolean().describe("Whether the current user has seen the issue after this update.").optional(),
+  isPublic: external_exports.boolean().describe("Whether the issue should be visible via a public permalink.").optional(),
+  assignedTo: external_exports.string().describe("The assignee actor id, username, or email address; use an empty string to unassign.").optional(),
+  isBookmarked: external_exports.boolean().describe("Whether the current user should bookmark the issue after this update.").optional(),
+  isSubscribed: external_exports.boolean().describe("Whether the current user should subscribe to issue notifications.").optional(),
+  statusDetails: external_exports.strictObject({
+    inCommit: external_exports.string().describe("The commit hash associated with the issue resolution.").optional(),
+    inRelease: external_exports.string().describe("The release version in which the issue is considered resolved.").optional(),
+    inNextRelease: external_exports.boolean().describe("Whether the issue is considered resolved in the next release.").optional()
+  }).describe("Additional issue resolution details sent to Sentry.").optional()
+}).describe("The input payload for updating one Sentry issue.");
+var updateIssueOutput = external_exports.strictObject({
+  issue: external_exports.looseObject({}).describe("A Sentry issue summary or detail payload.")
+}).describe("Action output.");
+var listOrganizationReleasesInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug whose releases should be listed."),
+  query: external_exports.string().describe("An optional release version prefix used to filter the release list.").optional()
+}).describe("The input payload for listing Sentry organization releases.");
+var listOrganizationReleasesOutput = external_exports.strictObject({
+  releases: external_exports.array(external_exports.looseObject({}).describe("A Sentry release payload.")).describe("The releases returned by Sentry.")
+}).describe("Action output.");
+var getOrganizationReleaseInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the release."),
+  version: external_exports.string().min(1).describe("The Sentry release version identifier to retrieve."),
+  health: external_exports.boolean().describe("Whether Sentry should include release health details in the response.").optional(),
+  summaryStatsPeriod: external_exports.string().describe("The relative time period used for release summary statistics.").optional(),
+  healthStatsPeriod: external_exports.string().describe("The relative time period used for release health statistics.").optional(),
+  adoptionStages: external_exports.boolean().describe("Whether Sentry should include release adoption stage information.").optional(),
+  projectId: external_exports.string().describe("An optional project id used to scope the release details.").optional(),
+  query: external_exports.string().describe("An optional Sentry query string used to filter release statistics.").optional(),
+  sort: external_exports.string().describe("The sort field used for release statistics in the Sentry response.").optional(),
+  status: external_exports.string().describe("An optional release status filter such as open or archived.").optional()
+}).describe("The input payload for retrieving one Sentry release.");
+var getOrganizationReleaseOutput = external_exports.strictObject({
+  release: external_exports.looseObject({}).describe("A Sentry release payload.")
+}).describe("Action output.");
+var getReleaseHealthStatsInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the release."),
+  version: external_exports.string().min(1).describe("The Sentry release version to filter release health statistics by."),
+  fields: external_exports.array(external_exports.string().min(1)).describe("The session metric fields that Sentry should calculate."),
+  groupBy: external_exports.array(external_exports.string().min(1)).describe("The session dimensions that Sentry should group by.").optional(),
+  query: external_exports.string().describe("An optional additional Sentry search query appended to the release filter.").optional(),
+  start: external_exports.string().describe("The inclusive ISO 8601 start time used to query release health data.").optional(),
+  end: external_exports.string().describe("The inclusive ISO 8601 end time used to query release health data.").optional(),
+  environments: external_exports.array(external_exports.string().min(1)).describe("The environment names used to filter release health statistics.").optional(),
+  projectIds: external_exports.array(external_exports.int().describe("A numeric Sentry project id.")).describe("The numeric Sentry project ids used to filter release health statistics.").optional(),
+  interval: external_exports.string().describe("The interval used for time-series release health statistics.").optional(),
+  statsPeriod: external_exports.string().describe("The relative time period such as 24h or 7d used for release health statistics.").optional(),
+  includeSeries: external_exports.int().describe("Whether Sentry should include series data, using 1 for yes and 0 for no.").optional(),
+  includeTotals: external_exports.int().describe("Whether Sentry should include totals data, using 1 for yes and 0 for no.").optional(),
+  perPage: external_exports.int().min(1).describe("The maximum number of grouped rows to return.").optional(),
+  orderBy: external_exports.string().describe("The metric field Sentry should order the grouped rows by.").optional()
+}).describe("The input payload for retrieving Sentry release health statistics.");
+var getReleaseHealthStatsOutput = external_exports.strictObject({
+  groups: external_exports.array(external_exports.looseObject({}).describe("A grouped release health statistics row.")).describe("The grouped release health statistics returned by Sentry."),
+  intervals: external_exports.array(external_exports.string().min(1)).describe("The interval boundaries returned by the Sentry sessions endpoint."),
+  start: external_exports.string().describe("The ISO 8601 start time applied to the statistics query.").nullable(),
+  end: external_exports.string().describe("The ISO 8601 end time applied to the statistics query.").nullable()
+}).describe("Action output.");
+var listOrganizationReplaysInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug whose replays should be listed."),
+  start: external_exports.string().describe("The inclusive ISO 8601 start time used to filter replays.").optional(),
+  end: external_exports.string().describe("The inclusive ISO 8601 end time used to filter replays.").optional(),
+  statsPeriod: external_exports.string().describe("The relative time period such as 1d or 7d used to filter replays.").optional(),
+  sort: external_exports.string().describe("The replay sort field returned by Sentry, optionally prefixed with -.").optional(),
+  field: external_exports.array(external_exports.string().min(1)).describe("Additional replay fields that Sentry should include in each result.").optional(),
+  query: external_exports.string().describe("The Sentry replay search query string used to filter results.").optional(),
+  cursor: external_exports.string().describe("The opaque Sentry pagination cursor for the replay results.").optional(),
+  projectIds: external_exports.array(external_exports.int().describe("A numeric Sentry project id.")).describe("The numeric Sentry project ids used to filter replays.").optional(),
+  perPage: external_exports.int().min(1).describe("The maximum number of replay rows to return.").optional(),
+  environment: external_exports.string().describe("The environment name used to filter replays.").optional()
+}).describe("The input payload for listing Sentry organization replays.");
+var listOrganizationReplaysOutput = external_exports.strictObject({
+  replays: external_exports.array(external_exports.looseObject({}).describe("A Sentry replay payload.")).describe("The replays returned by Sentry."),
+  nextCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the next page, or null when there are no more results.").nullable(),
+  previousCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the previous page, or null when there are no earlier results.").nullable()
+}).describe("Action output.");
+var getReplayInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the replay."),
+  replayId: external_exports.string().min(1).describe("The replay id to retrieve."),
+  start: external_exports.string().describe("The inclusive ISO 8601 start time used to scope replay detail metrics.").optional(),
+  end: external_exports.string().describe("The inclusive ISO 8601 end time used to scope replay detail metrics.").optional(),
+  statsPeriod: external_exports.string().describe("The relative time period such as 1h or 7d used to scope replay detail metrics.").optional(),
+  sort: external_exports.string().describe("The replay detail sort field returned by Sentry, optionally prefixed with -.").optional(),
+  field: external_exports.array(external_exports.string().min(1)).describe("Additional replay detail fields that Sentry should include in the response.").optional(),
+  query: external_exports.string().describe("The Sentry replay search query string used to scope the replay detail response.").optional(),
+  cursor: external_exports.string().describe("The opaque Sentry pagination cursor for nested replay detail data.").optional(),
+  projectIds: external_exports.array(external_exports.int().describe("A numeric Sentry project id.")).describe("The numeric Sentry project ids used to scope replay details.").optional(),
+  perPage: external_exports.int().min(1).describe("The maximum number of nested replay detail rows to return.").optional(),
+  environment: external_exports.string().describe("The environment name used to scope replay details.").optional()
+}).describe("The input payload for retrieving one Sentry replay.");
+var getReplayOutput = external_exports.strictObject({
+  replay: external_exports.looseObject({}).describe("A Sentry replay payload."),
+  nextCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the next page, or null when there are no more results.").nullable(),
+  previousCursor: external_exports.string().describe("The opaque Sentry cursor from the Link header for the previous page, or null when there are no earlier results.").nullable()
+}).describe("Action output.");
+var listAlertsInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug whose alert workflows should be listed."),
+  ids: external_exports.array(external_exports.string().min(1)).describe("Specific alert workflow ids that Sentry should filter the list to.").optional(),
+  query: external_exports.string().describe("An optional free-text search query used to filter alert workflows.").optional(),
+  sortBy: external_exports.string().describe("The alert workflow sort field, optionally prefixed with - for descending.").optional(),
+  projectIds: external_exports.array(external_exports.int().describe("A numeric Sentry project id.")).describe("The numeric Sentry project ids used to filter alert workflows.").optional()
+}).describe("The input payload for listing Sentry alert workflows.");
+var listAlertsOutput = external_exports.strictObject({
+  alerts: external_exports.array(external_exports.looseObject({}).describe("A Sentry alert workflow payload.")).describe("The alert workflows returned by Sentry.")
+}).describe("Action output.");
+var getAlertInput = external_exports.strictObject({
+  organizationIdOrSlug: external_exports.string().min(1).describe("The organization id or slug that owns the alert workflow."),
+  alertId: external_exports.string().min(1).describe("The alert workflow id to retrieve.")
+}).describe("The input payload for retrieving one Sentry alert workflow.");
+var getAlertOutput = external_exports.strictObject({
+  alert: external_exports.looseObject({}).describe("A Sentry alert workflow payload.")
+}).describe("Action output.");
+var sentryActions = {
+  list_organization_integrations: {
+    description: "List installed integrations for a Sentry organization, with optional provider and feature filters.",
+    effect: "read",
+    inputSchema: listOrganizationIntegrationsInput,
+    outputSchema: external_exports.toJSONSchema(listOrganizationIntegrationsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_organization_integration: {
+    description: "Get one installed Sentry organization integration by its integration id.",
+    effect: "read",
+    inputSchema: getOrganizationIntegrationInput,
+    outputSchema: external_exports.toJSONSchema(getOrganizationIntegrationOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_organization_integration_config: {
+    description: "List available integration provider configs for a Sentry organization, optionally filtered by provider key.",
+    effect: "read",
+    inputSchema: getOrganizationIntegrationConfigInput,
+    outputSchema: external_exports.toJSONSchema(getOrganizationIntegrationConfigOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_organization_sentry_apps: {
+    description: "List the custom Sentry Apps created by a Sentry organization.",
+    effect: "read",
+    inputSchema: listOrganizationSentryAppsInput,
+    outputSchema: external_exports.toJSONSchema(listOrganizationSentryAppsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_sentry_app: {
+    description: "Get one Sentry App by id or slug, including integration metadata and OAuth client settings.",
+    effect: "read",
+    inputSchema: getSentryAppInput,
+    outputSchema: external_exports.toJSONSchema(getSentryAppOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_organization_projects: {
+    description: "List projects that belong to a Sentry organization.",
+    effect: "read",
+    inputSchema: listOrganizationProjectsInput,
+    outputSchema: external_exports.toJSONSchema(listOrganizationProjectsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_project: {
+    description: "Get one Sentry project by organization and project slug or id.",
+    effect: "read",
+    inputSchema: getProjectInput,
+    outputSchema: external_exports.toJSONSchema(getProjectOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_organization_issues: {
+    description: "List issues for a Sentry organization with optional search, project, and environment filters.",
+    effect: "read",
+    inputSchema: listOrganizationIssuesInput,
+    outputSchema: external_exports.toJSONSchema(listOrganizationIssuesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_issue: {
+    description: "Get one issue in a Sentry organization by numeric id or short id.",
+    effect: "read",
+    inputSchema: getIssueInput,
+    outputSchema: external_exports.toJSONSchema(getIssueOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_issue_event: {
+    description: "Get one event for a Sentry issue by event id, or use latest, oldest, or recommended selectors.",
+    effect: "read",
+    inputSchema: getIssueEventInput,
+    outputSchema: external_exports.toJSONSchema(getIssueEventOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_issue_events: {
+    description: "List events that belong to one Sentry issue, with optional event query filters.",
+    effect: "read",
+    inputSchema: listIssueEventsInput,
+    outputSchema: external_exports.toJSONSchema(listIssueEventsOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_issue: {
+    description: "Update mutable attributes on one Sentry issue, such as status, assignment, or bookmarks.",
+    effect: "write",
+    inputSchema: updateIssueInput,
+    outputSchema: external_exports.toJSONSchema(updateIssueOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_organization_releases: {
+    description: "List releases that belong to a Sentry organization, optionally filtered by version prefix.",
+    effect: "read",
+    inputSchema: listOrganizationReleasesInput,
+    outputSchema: external_exports.toJSONSchema(listOrganizationReleasesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_organization_release: {
+    description: "Get one release in a Sentry organization, with optional health and summary statistics included.",
+    effect: "read",
+    inputSchema: getOrganizationReleaseInput,
+    outputSchema: external_exports.toJSONSchema(getOrganizationReleaseOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_release_health_stats: {
+    description: "Retrieve release health session statistics for one Sentry release by querying the sessions endpoint with that release version.",
+    effect: "read",
+    inputSchema: getReleaseHealthStatsInput,
+    outputSchema: external_exports.toJSONSchema(getReleaseHealthStatsOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_organization_replays: {
+    description: "List session replays for a Sentry organization, with optional project and environment filters.",
+    effect: "read",
+    inputSchema: listOrganizationReplaysInput,
+    outputSchema: external_exports.toJSONSchema(listOrganizationReplaysOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_replay: {
+    description: "Get one replay instance in a Sentry organization by replay id.",
+    effect: "read",
+    inputSchema: getReplayInput,
+    outputSchema: external_exports.toJSONSchema(getReplayOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_alerts: {
+    description: "List alert workflows for a Sentry organization, with optional id, project, and search filters.",
+    effect: "read",
+    inputSchema: listAlertsInput,
+    outputSchema: external_exports.toJSONSchema(listAlertsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_alert: {
+    description: "Get one alert workflow in a Sentry organization by workflow id.",
+    effect: "read",
+    inputSchema: getAlertInput,
+    outputSchema: external_exports.toJSONSchema(getAlertOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/sentry/index.ts
+function createSentryPlugin() {
+  return createProviderPlugin({
+    description: "Sentry",
+    actions: sentryActions,
+    oauth: {
+      authorizationUrl: "https://sentry.io/oauth/authorize/",
+      tokenUrl: "https://sentry.io/oauth/token/",
+      scopes: ["org:read", "project:read", "project:releases", "event:read", "event:write"]
+    },
+    handlers: {
+      list_organization_integrations: listOrganizationIntegrations,
+      get_organization_integration: getOrganizationIntegration,
+      get_organization_integration_config: getOrganizationIntegrationConfig,
+      list_organization_sentry_apps: listOrganizationSentryApps,
+      get_sentry_app: getSentryApp,
+      list_organization_projects: listOrganizationProjects,
+      get_project: getProject,
+      list_organization_issues: listOrganizationIssues,
+      get_issue: getIssue,
+      get_issue_event: getIssueEvent,
+      list_issue_events: listIssueEvents,
+      update_issue: updateIssue,
+      list_organization_releases: listOrganizationReleases,
+      get_organization_release: getOrganizationRelease,
+      get_release_health_stats: getReleaseHealthStats,
+      list_organization_replays: listOrganizationReplays,
+      get_replay: getReplay,
+      list_alerts: listAlerts,
+      get_alert: getAlert
+    }
+  });
+}
+var sentry_default = createSentryPlugin();
+export {
+  createSentryPlugin,
+  sentry_default as default
+};