@tool-bridge/server 0.1.1 → 0.3.0

package/dist/linear-H3VU4PSD.js

@@ -0,0 +1,2163 @@
+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/linear/api.ts
+var SERVICE = "linear";
+var GRAPHQL_URL = "https://api.linear.app/graphql";
+var MAX_PAGES = 100;
+var pageInfoFields = `
+  startCursor
+  endCursor
+  hasPreviousPage
+  hasNextPage
+`;
+var userFields = `
+  id
+  name
+  displayName
+  email
+  avatarUrl
+  active
+  admin
+  createdAt
+`;
+var teamFields = `
+  id
+  name
+  key
+`;
+var workflowStateFields = `
+  id
+  name
+  type
+  color
+  description
+`;
+var labelFields = `
+  id
+  name
+  color
+  description
+  isGroup
+  parent {
+    id
+    name
+  }
+`;
+var cycleFields = `
+  id
+  name
+  number
+  description
+  startsAt
+  endsAt
+  completedAt
+  isActive
+  isFuture
+  isPast
+  isNext
+  isPrevious
+  team {
+    ${teamFields}
+  }
+`;
+var projectStatusFields = `
+  id
+  name
+  type
+  color
+  description
+`;
+var projectFields = `
+  id
+  name
+  description
+  url
+  slugId
+  icon
+  color
+  state
+  health
+  progress
+  priority
+  priorityLabel
+  scope
+  startDate
+  targetDate
+  createdAt
+  updatedAt
+  lead {
+    ${userFields}
+  }
+  creator {
+    ${userFields}
+  }
+  status {
+    ${projectStatusFields}
+  }
+`;
+var initiativeFields = `
+  id
+  name
+  description
+  url
+`;
+var attachmentFields = `
+  id
+  title
+  subtitle
+  url
+  sourceType
+  metadata
+  source
+  createdAt
+  updatedAt
+  issue {
+    id
+    identifier
+    title
+  }
+`;
+var reactionFields = `
+  id
+  emoji
+  createdAt
+  updatedAt
+  user {
+    ${userFields}
+  }
+  comment {
+    id
+  }
+  issue {
+    id
+    identifier
+  }
+  projectUpdate {
+    id
+  }
+`;
+var commentFields = `
+  id
+  body
+  url
+  quotedText
+  createdAt
+  updatedAt
+  editedAt
+  resolvedAt
+  issueId
+  parentId
+  projectUpdateId
+  user {
+    ${userFields}
+  }
+  reactions {
+    ${reactionFields}
+  }
+`;
+var issueFields = `
+  id
+  identifier
+  title
+  description
+  url
+  createdAt
+  updatedAt
+  archivedAt
+  completedAt
+  dueDate
+  priority
+  estimate
+  team {
+    ${teamFields}
+  }
+  state {
+    ${workflowStateFields}
+  }
+  project {
+    ${projectFields}
+  }
+  assignee {
+    ${userFields}
+  }
+  creator {
+    ${userFields}
+  }
+  cycle {
+    ${cycleFields}
+  }
+  parent {
+    id
+    identifier
+    title
+  }
+  labels(first: 50) {
+    nodes {
+      ${labelFields}
+    }
+  }
+`;
+var detailedIssueFields = `
+  ${issueFields}
+  attachments(first: 50) {
+    nodes {
+      ${attachmentFields}
+    }
+    pageInfo {
+      ${pageInfoFields}
+    }
+  }
+  comments(first: 50) {
+    nodes {
+      ${commentFields}
+    }
+    pageInfo {
+      ${pageInfoFields}
+    }
+  }
+  subscribers(first: 50) {
+    nodes {
+      ${userFields}
+    }
+    pageInfo {
+      ${pageInfoFields}
+    }
+  }
+  reactions {
+    ${reactionFields}
+  }
+`;
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function bool(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function compact(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) output[key] = value;
+  }
+  return output;
+}
+function nodesOf(connection) {
+  const nodes = asRecord(connection)?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+function basenameFromUrl(url) {
+  const withoutQuery = url.includes("?") ? url.slice(0, url.indexOf("?")) : url;
+  const lastSlash = withoutQuery.lastIndexOf("/");
+  return lastSlash >= 0 ? withoutQuery.slice(lastSlash + 1) : withoutQuery;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = [];
+  for (let index = 0; index < items.length; index += concurrency) {
+    results.push(...await Promise.all(items.slice(index, index + concurrency).map(mapper)));
+  }
+  return results;
+}
+async function readJson(response) {
+  const text = await response.text().catch(() => "");
+  if (text === "") return {};
+  try {
+    return asRecord(JSON.parse(text)) ?? { message: text };
+  } catch {
+    return { message: text };
+  }
+}
+function extractErrorMessage(body) {
+  const direct = str(body.message);
+  if (direct !== void 0) return direct;
+  if (Array.isArray(body.errors) && body.errors.length > 0) {
+    const joined = body.errors.map((error) => str(asRecord(error)?.message)).filter((message) => message !== void 0).join("; ");
+    if (joined !== "") return joined;
+  }
+  return "linear \u8BF7\u6C42\u5931\u8D25";
+}
+function graphqlErrorsToTBError(errors) {
+  const message = errors.map((error) => typeof error.message === "string" ? error.message : "").join("; ");
+  const lower = message.toLowerCase();
+  if (lower.includes("cannot query field") || lower.includes("syntax error") || lower.includes("entity not found") || lower.includes("invalid") || lower.includes("expected type") || lower.includes("required type") || lower.includes("must be")) {
+    return upstreamError(400, message);
+  }
+  if (lower.includes("unauthorized") || lower.includes("authentication")) {
+    return upstreamError(401, message);
+  }
+  if (lower.includes("rate limit")) {
+    return upstreamError(429, message);
+  }
+  return upstreamError(502, message);
+}
+async function graphqlRequest(ctx, query, variables) {
+  const authorization = requireApiKey(ctx, SERVICE);
+  let response;
+  let body;
+  try {
+    response = await guardedFetch(GRAPHQL_URL, {
+      method: "POST",
+      headers: {
+        "accept": "application/json",
+        "authorization": authorization,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(compact({ query, variables }))
+    });
+    body = await readJson(response);
+  } catch (error) {
+    if (error instanceof TBError) throw error;
+    throw upstreamError(502, error instanceof Error ? `linear \u8BF7\u6C42\u5931\u8D25: ${error.message}` : "linear \u8BF7\u6C42\u5931\u8D25");
+  }
+  if (!response.ok) throw upstreamError(response.status, extractErrorMessage(body));
+  const errors = Array.isArray(body.errors) ? body.errors.map((error) => asRecord(error) ?? { message: String(error) }) : void 0;
+  return {
+    // `data: null` 与"没有 data 字段"要分开:前者是 GraphQL 明确说"这次没有数据"。
+    data: body.data === null ? null : asRecord(body.data),
+    errors,
+    extensions: asRecord(body.extensions)
+  };
+}
+async function operation(ctx, query, variables) {
+  const response = await graphqlRequest(ctx, query, variables);
+  if (response.errors !== void 0 && response.errors.length > 0) {
+    throw graphqlErrorsToTBError(response.errors);
+  }
+  if (response.data === null || response.data === void 0) {
+    throw upstreamError(502, "linear graphql \u54CD\u5E94\u91CC\u6CA1\u6709 data");
+  }
+  return response.data;
+}
+async function rawDocument(ctx, document, variables) {
+  const response = await graphqlRequest(ctx, document, variables);
+  const hasErrors = response.errors !== void 0 && response.errors.length > 0;
+  return compact({
+    data: response.data === null ? null : response.data,
+    errors: response.errors,
+    extensions: response.extensions,
+    message: hasErrors ? response.errors.map((error) => typeof error.message === "string" ? error.message : "").join("; ") : void 0
+  });
+}
+async function fetchAllNodes(ctx, query, extract) {
+  const nodes = [];
+  let after;
+  for (let page = 0; ; page += 1) {
+    if (page >= MAX_PAGES) {
+      throw upstreamError(502, `linear \u7FFB\u9875\u8D85\u8FC7 ${MAX_PAGES} \u9875,\u4E0A\u6E38\u6E38\u6807\u53EF\u80FD\u6CA1\u6709\u63A8\u8FDB`);
+    }
+    const data = await operation(ctx, query, { after });
+    const connection = asRecord(extract(data));
+    if (connection === void 0) return nodes;
+    nodes.push(...nodesOf(connection));
+    const pageInfo = asRecord(connection.pageInfo);
+    const endCursor = str(pageInfo?.endCursor);
+    if (pageInfo?.hasNextPage !== true || endCursor === void 0) return nodes;
+    after = endCursor;
+  }
+}
+function requireEntity(value, message) {
+  const record = asRecord(value);
+  if (record === void 0) throw new TBError("invalid_argument", message);
+  return record;
+}
+async function fetchIssueById(ctx, issueId) {
+  const payload = await operation(ctx, `
+    query GetIssue($id: String!) {
+      issue(id: $id) {
+        ${detailedIssueFields}
+      }
+    }
+  `, { id: issueId });
+  return requireEntity(payload.issue, "linear issue \u4E0D\u5B58\u5728");
+}
+async function fetchProjectById(ctx, projectId, includeTeams, includeMembers, includeInitiatives) {
+  const payload = await operation(ctx, `
+    query GetProject(
+      $id: String!
+      $includeTeams: Boolean!
+      $includeMembers: Boolean!
+      $includeInitiatives: Boolean!
+    ) {
+      project(id: $id) {
+        ${projectFields}
+        teams(first: 50, includeArchived: false) @include(if: $includeTeams) {
+          nodes {
+            ${teamFields}
+          }
+        }
+        members(first: 100, includeArchived: false, includeDisabled: true) @include(if: $includeMembers) {
+          nodes {
+            ${userFields}
+          }
+        }
+        initiatives(first: 50, includeArchived: false) @include(if: $includeInitiatives) {
+          nodes {
+            ${initiativeFields}
+          }
+        }
+      }
+    }
+  `, { id: projectId, includeTeams, includeMembers, includeInitiatives });
+  return requireEntity(payload.project, "linear project \u4E0D\u5B58\u5728");
+}
+async function fetchAttachmentById(ctx, attachmentId) {
+  const payload = await operation(ctx, `
+    query GetAttachment($id: String!) {
+      attachment(id: $id) {
+        ${attachmentFields}
+      }
+    }
+  `, { id: attachmentId });
+  return requireEntity(payload.attachment, "linear attachment \u4E0D\u5B58\u5728");
+}
+async function fetchIssueLabelById(ctx, labelId) {
+  const payload = await operation(ctx, `
+    query GetIssueLabel($id: String!) {
+      issueLabel(id: $id) {
+        ${labelFields}
+        team {
+          ${teamFields}
+        }
+      }
+    }
+  `, { id: labelId });
+  return requireEntity(payload.issueLabel, "linear label \u4E0D\u5B58\u5728");
+}
+async function fetchCommentById(ctx, commentId) {
+  const payload = await operation(ctx, `
+    query GetComment($id: String!) {
+      comment(id: $id) {
+        ${commentFields}
+      }
+    }
+  `, { id: commentId });
+  return requireEntity(payload.comment, "linear comment \u4E0D\u5B58\u5728");
+}
+async function fetchIssueRelationById(ctx, relationId) {
+  const payload = await operation(ctx, `
+    query GetIssueRelation($id: String!) {
+      issueRelation(id: $id) {
+        id
+        type
+        issue {
+          id
+        }
+        relatedIssue {
+          id
+        }
+      }
+    }
+  `, { id: relationId });
+  return requireEntity(payload.issueRelation, "linear issue relation \u4E0D\u5B58\u5728");
+}
+async function fetchProjectMilestoneById(ctx, milestoneId) {
+  const payload = await operation(ctx, `
+    query GetProjectMilestone($id: String!) {
+      projectMilestone(id: $id) {
+        id
+        name
+        description
+        targetDate
+        sortOrder
+        progress
+        status
+        project {
+          id
+        }
+      }
+    }
+  `, { id: milestoneId });
+  return requireEntity(payload.projectMilestone, "linear project milestone \u4E0D\u5B58\u5728");
+}
+async function fetchProjectUpdateById(ctx, projectUpdateId) {
+  const payload = await operation(ctx, `
+    query GetProjectUpdate($id: String!) {
+      projectUpdate(id: $id) {
+        id
+        body
+        health
+        isDiffHidden
+        isStale
+        url
+        createdAt
+        updatedAt
+        editedAt
+        slugId
+        project {
+          id
+        }
+        user {
+          ${userFields}
+        }
+        reactions {
+          ${reactionFields}
+        }
+        commentCount
+      }
+    }
+  `, { id: projectUpdateId });
+  return requireEntity(payload.projectUpdate, "linear project update \u4E0D\u5B58\u5728");
+}
+async function fetchViewer(ctx) {
+  const payload = await operation(ctx, `
+    query Viewer {
+      viewer {
+        ${userFields}
+      }
+    }
+  `, {});
+  const viewer = asRecord(payload.viewer);
+  if (viewer === void 0) throw upstreamError(502, "linear viewer \u67E5\u8BE2\u56DE\u4E86\u7A7A\u54CD\u5E94");
+  return viewer;
+}
+async function fetchIssueAttachments(ctx, issueId) {
+  const payload = await operation(ctx, `
+    query GetIssueAttachments($id: String!) {
+      issue(id: $id) {
+        attachments(first: 100, includeArchived: false) {
+          nodes {
+            ${attachmentFields}
+          }
+        }
+      }
+    }
+  `, { id: issueId });
+  return nodesOf(requireEntity(payload.issue, "linear issue \u4E0D\u5B58\u5728").attachments);
+}
+async function fetchTeamCycles(ctx, teamId) {
+  const payload = await operation(ctx, `
+    query GetTeamCycles($id: String!) {
+      team(id: $id) {
+        cycles(first: 100, includeArchived: false) {
+          nodes {
+            ${cycleFields}
+          }
+        }
+      }
+    }
+  `, { id: teamId });
+  return nodesOf(requireEntity(payload.team, "linear team \u4E0D\u5B58\u5728").cycles);
+}
+async function fetchTeamLabels(ctx, teamId) {
+  const payload = await operation(ctx, `
+    query GetTeamLabels($id: String!) {
+      team(id: $id) {
+        labels(first: 100, includeArchived: false) {
+          nodes {
+            ${labelFields}
+          }
+        }
+      }
+    }
+  `, { id: teamId });
+  return nodesOf(requireEntity(payload.team, "linear team \u4E0D\u5B58\u5728").labels);
+}
+async function fetchTeamStates(ctx, teamId) {
+  const payload = await operation(ctx, `
+    query GetTeamStates($id: String!) {
+      team(id: $id) {
+        states(first: 100, includeArchived: false) {
+          nodes {
+            ${workflowStateFields}
+          }
+        }
+      }
+    }
+  `, { id: teamId });
+  return nodesOf(requireEntity(payload.team, "linear team \u4E0D\u5B58\u5728").states);
+}
+async function fetchTeamDetails(ctx, teamId) {
+  const payload = await operation(ctx, `
+    query GetTeamDetails($id: String!) {
+      team(id: $id) {
+        ${teamFields}
+        members(first: 100, includeDisabled: true) {
+          nodes {
+            ${userFields}
+          }
+        }
+        projects(first: 100, includeArchived: false) {
+          nodes {
+            ${projectFields}
+          }
+        }
+      }
+    }
+  `, { id: teamId });
+  return requireEntity(payload.team, "linear team \u4E0D\u5B58\u5728");
+}
+async function resolveAssigneeFilterId(ctx, assigneeId) {
+  if (assigneeId === void 0) return void 0;
+  if (assigneeId !== "me") return assigneeId;
+  return String((await fetchViewer(ctx)).id);
+}
+function buildIssuesFilter(projectId, assigneeId) {
+  const filter = compact({
+    project: projectId === void 0 ? void 0 : { id: { eq: projectId } },
+    assignee: assigneeId === void 0 ? void 0 : { id: { eq: assigneeId } }
+  });
+  return Object.keys(filter).length > 0 ? filter : void 0;
+}
+async function resolveProjectStatusId(ctx, statusType) {
+  const payload = await operation(ctx, `
+    query GetProjectStatuses {
+      organization {
+        projectStatuses {
+          id
+          type
+        }
+      }
+    }
+  `, {});
+  const statuses = asRecord(payload.organization)?.projectStatuses;
+  const list = Array.isArray(statuses) ? statuses : [];
+  const matched = list.map((item) => asRecord(item)).find((item) => item?.type === statusType);
+  const id = str(matched?.id);
+  if (id === void 0) throw new TBError("invalid_argument", `linear \u6CA1\u6709 state \u4E3A ${statusType} \u7684 project status`);
+  return id;
+}
+function mutationEntityId(payload, entityKey, message) {
+  const record = asRecord(payload);
+  const id = str(asRecord(record?.[entityKey])?.id);
+  if (record?.success !== true || id === void 0) throw upstreamError(502, message);
+  return id;
+}
+function archiveEntityId(payload, message) {
+  const record = asRecord(payload);
+  const id = str(asRecord(record?.entity)?.id);
+  if (record?.success !== true || id === void 0) throw upstreamError(502, message);
+  return id;
+}
+function requireSuccess(payload, message) {
+  if (asRecord(payload)?.success !== true) throw upstreamError(502, message);
+}
+function mapPageInfo(pageInfo) {
+  const info = asRecord(pageInfo);
+  return {
+    startCursor: info?.startCursor ?? null,
+    endCursor: info?.endCursor ?? null,
+    hasPreviousPage: Boolean(info?.hasPreviousPage),
+    hasNextPage: Boolean(info?.hasNextPage)
+  };
+}
+function mapSnakePageInfo(pageInfo) {
+  const info = asRecord(pageInfo);
+  return {
+    end_cursor: info?.endCursor ?? null,
+    has_next_page: Boolean(info?.hasNextPage)
+  };
+}
+function mapUser(user) {
+  const record = asRecord(user);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    name: str(record.name),
+    displayName: str(record.displayName),
+    email: str(record.email),
+    avatarUrl: str(record.avatarUrl),
+    active: bool(record.active),
+    admin: bool(record.admin),
+    createdAt: str(record.createdAt)
+  });
+}
+function mapTeam(team) {
+  const record = asRecord(team);
+  if (record === void 0) return null;
+  return compact({ id: str(record.id), name: str(record.name), key: str(record.key) });
+}
+function mapWorkflowState(state) {
+  const record = asRecord(state);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    name: str(record.name),
+    type: str(record.type),
+    color: str(record.color),
+    description: str(record.description)
+  });
+}
+function mapLabel(label) {
+  const record = asRecord(label);
+  if (record === void 0) return null;
+  const parent = asRecord(record.parent);
+  return compact({
+    id: str(record.id),
+    name: str(record.name),
+    color: str(record.color),
+    description: str(record.description),
+    is_group: bool(record.isGroup),
+    parent: parent === void 0 ? null : compact({ id: str(parent.id), name: str(parent.name) })
+  });
+}
+function mapCycle(cycle) {
+  const record = asRecord(cycle);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    name: str(record.name),
+    number: num(record.number),
+    description: str(record.description),
+    startsAt: str(record.startsAt),
+    endsAt: str(record.endsAt),
+    completedAt: str(record.completedAt),
+    isActive: bool(record.isActive),
+    isFuture: bool(record.isFuture),
+    isPast: bool(record.isPast),
+    team: mapTeam(record.team)
+  });
+}
+function mapProjectStatus(status) {
+  const record = asRecord(status);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    name: str(record.name),
+    type: str(record.type),
+    color: str(record.color),
+    description: str(record.description)
+  });
+}
+function mapProject(project, options = {}) {
+  const record = asRecord(project);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    name: str(record.name),
+    description: str(record.description),
+    url: str(record.url),
+    slugId: str(record.slugId),
+    icon: str(record.icon),
+    color: str(record.color),
+    state: str(record.state),
+    health: str(record.health),
+    progress: num(record.progress),
+    priority: num(record.priority),
+    priorityLabel: str(record.priorityLabel),
+    scope: num(record.scope),
+    startDate: str(record.startDate),
+    targetDate: str(record.targetDate),
+    createdAt: str(record.createdAt),
+    updatedAt: str(record.updatedAt),
+    lead: mapUser(record.lead),
+    creator: mapUser(record.creator),
+    status: mapProjectStatus(record.status),
+    // 这三块只在调用方明确要了、且上游确实回了的时候才出现 —— 没要就整个键都不该在。
+    teams: options.includeTeams === true && record.teams !== void 0 ? { nodes: nodesOf(record.teams).map(mapTeam) } : void 0,
+    members: options.includeMembers === true && record.members !== void 0 ? { nodes: nodesOf(record.members).map(mapUser) } : void 0,
+    initiatives: options.includeInitiatives === true && record.initiatives !== void 0 ? {
+      nodes: nodesOf(record.initiatives).map((initiative) => {
+        const item = asRecord(initiative) ?? {};
+        return compact({
+          id: str(item.id),
+          name: str(item.name),
+          description: str(item.description),
+          url: str(item.url)
+        });
+      })
+    } : void 0
+  });
+}
+function mapAttachment(attachment) {
+  const record = asRecord(attachment);
+  if (record === void 0) return null;
+  const issue = asRecord(record.issue);
+  return compact({
+    id: str(record.id),
+    title: str(record.title),
+    subtitle: str(record.subtitle),
+    url: str(record.url),
+    sourceType: str(record.sourceType),
+    metadata: asRecord(record.metadata),
+    source: asRecord(record.source),
+    issue: issue === void 0 ? null : compact({ id: str(issue.id), identifier: str(issue.identifier), title: str(issue.title) }),
+    createdAt: str(record.createdAt),
+    updatedAt: str(record.updatedAt)
+  });
+}
+function mapReaction(reaction) {
+  const record = asRecord(reaction);
+  if (record === void 0) return null;
+  const comment = asRecord(record.comment);
+  const issue = asRecord(record.issue);
+  const projectUpdate = asRecord(record.projectUpdate);
+  return compact({
+    id: str(record.id),
+    emoji: str(record.emoji),
+    createdAt: str(record.createdAt),
+    updatedAt: str(record.updatedAt),
+    user: mapUser(record.user),
+    comment: comment === void 0 ? null : { id: str(comment.id) },
+    issue: issue === void 0 ? null : compact({ id: str(issue.id), identifier: str(issue.identifier) }),
+    projectUpdate: projectUpdate === void 0 ? null : { id: str(projectUpdate.id) }
+  });
+}
+function mapComment(comment) {
+  const record = asRecord(comment);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    body: str(record.body),
+    url: str(record.url),
+    quotedText: str(record.quotedText),
+    createdAt: str(record.createdAt),
+    updatedAt: str(record.updatedAt),
+    editedAt: str(record.editedAt),
+    resolvedAt: str(record.resolvedAt),
+    issueId: str(record.issueId),
+    parentId: str(record.parentId),
+    projectUpdateId: str(record.projectUpdateId),
+    user: mapUser(record.user),
+    // reactions 在 Linear 这里是裸数组而不是 connection,不能走 nodesOf。
+    reactions: Array.isArray(record.reactions) ? record.reactions.map(mapReaction) : []
+  });
+}
+function mapIssueSummary(issue) {
+  const record = asRecord(issue);
+  if (record === void 0) return null;
+  return compact({
+    id: str(record.id),
+    identifier: str(record.identifier),
+    title: str(record.title),
+    description: str(record.description),
+    url: str(record.url),
+    createdAt: str(record.createdAt),
+    updatedAt: str(record.updatedAt),
+    archivedAt: str(record.archivedAt),
+    dueDate: str(record.dueDate),
+    priority: num(record.priority),
+    estimate: num(record.estimate),
+    team: mapTeam(record.team),
+    state: mapWorkflowState(record.state),
+    project: mapProject(record.project),
+    assignee: mapUser(record.assignee),
+    labels: { nodes: nodesOf(record.labels).map(mapLabel) }
+  });
+}
+function mapDetailedIssue(issue) {
+  const base = mapIssueSummary(issue);
+  if (base === null) return null;
+  const record = asRecord(issue) ?? {};
+  const parent = asRecord(record.parent);
+  return compact({
+    ...base,
+    creator: mapUser(record.creator),
+    cycle: mapCycle(record.cycle),
+    parent: parent === void 0 ? null : compact({ id: str(parent.id), identifier: str(parent.identifier), title: str(parent.title) }),
+    attachments: {
+      nodes: nodesOf(record.attachments).map(mapAttachment),
+      pageInfo: mapPageInfo(asRecord(record.attachments)?.pageInfo)
+    },
+    comments: {
+      nodes: nodesOf(record.comments).map(mapComment),
+      pageInfo: mapPageInfo(asRecord(record.comments)?.pageInfo)
+    },
+    subscribers: {
+      nodes: nodesOf(record.subscribers).map(mapUser),
+      pageInfo: mapPageInfo(asRecord(record.subscribers)?.pageInfo)
+    },
+    reactions: Array.isArray(record.reactions) ? record.reactions.map(mapReaction) : []
+  });
+}
+function mapDraft(draft) {
+  const record = asRecord(draft);
+  if (record === void 0) return null;
+  const issue = asRecord(record.issue);
+  const project = asRecord(record.project);
+  const projectUpdate = asRecord(record.projectUpdate);
+  return compact({
+    id: str(record.id),
+    data: asRecord(record.data),
+    bodyData: str(record.bodyData),
+    createdAt: str(record.createdAt),
+    updatedAt: str(record.updatedAt),
+    isAutogenerated: bool(record.isAutogenerated),
+    team: mapTeam(record.team),
+    issue: issue === void 0 ? null : { id: str(issue.id) },
+    project: project === void 0 ? null : { id: str(project.id) },
+    projectUpdate: projectUpdate === void 0 ? null : { id: str(projectUpdate.id) },
+    user: mapUser(record.user)
+  });
+}
+async function createAttachment(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateAttachment($input: AttachmentCreateInput!) {
+      attachmentCreate(input: $input) {
+        success
+        attachment {
+          id
+        }
+      }
+    }
+  `, {
+    input: compact({
+      issueId: input.issue_id,
+      title: input.title,
+      url: input.url,
+      subtitle: str(input.subtitle)
+    })
+  });
+  const attachmentId = mutationEntityId(payload.attachmentCreate, "attachment", "linear create_attachment \u5931\u8D25");
+  const attachment = await fetchAttachmentById(ctx, attachmentId);
+  return {
+    id: attachment.id,
+    issue_id: asRecord(attachment.issue)?.id ?? input.issue_id,
+    title: attachment.title,
+    url: attachment.url,
+    subtitle: attachment.subtitle ?? null
+  };
+}
+async function createCommentReaction(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateCommentReaction($input: ReactionCreateInput!) {
+      reactionCreate(input: $input) {
+        success
+        reaction {
+          id
+        }
+      }
+    }
+  `, { input: { commentId: input.comment_id, emoji: input.emoji } });
+  return {
+    reaction_id: mutationEntityId(payload.reactionCreate, "reaction", "linear create_comment_reaction \u5931\u8D25"),
+    comment_id: input.comment_id,
+    emoji: input.emoji
+  };
+}
+async function createLinearComment(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateComment($input: CommentCreateInput!) {
+      commentCreate(input: $input) {
+        success
+        comment {
+          id
+        }
+      }
+    }
+  `, { input: { issueId: input.issueId, body: input.body } });
+  const commentId = mutationEntityId(payload.commentCreate, "comment", "linear create_linear_comment \u5931\u8D25");
+  const comment = await fetchCommentById(ctx, commentId);
+  return {
+    comment_id: comment.id,
+    issue_id: comment.issueId ?? input.issueId,
+    body: comment.body ?? input.body
+  };
+}
+async function createLinearIssue(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateIssue($input: IssueCreateInput!) {
+      issueCreate(input: $input) {
+        success
+        issue {
+          id
+        }
+      }
+    }
+  `, {
+    input: compact({
+      title: input.title,
+      teamId: input.team_id,
+      cycleId: str(input.cycle_id),
+      dueDate: str(input.due_date),
+      estimate: input.estimate,
+      priority: input.priority,
+      stateId: str(input.state_id),
+      labelIds: input.label_ids,
+      parentId: str(input.parent_id),
+      projectId: str(input.project_id),
+      assigneeId: str(input.assignee_id),
+      description: str(input.description)
+    })
+  });
+  const issueId = mutationEntityId(payload.issueCreate, "issue", "linear create_linear_issue \u5931\u8D25");
+  const issue = await fetchIssueById(ctx, issueId);
+  return {
+    id: issue.id,
+    identifier: issue.identifier,
+    issue_title: issue.title,
+    issue_description: issue.description ?? null,
+    ticket_url: issue.url
+  };
+}
+async function createLinearIssueRelation(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateIssueRelation($input: IssueRelationCreateInput!) {
+      issueRelationCreate(input: $input) {
+        success
+        issueRelation {
+          id
+        }
+      }
+    }
+  `, {
+    input: {
+      issueId: input.issue_id,
+      relatedIssueId: input.related_issue_id,
+      type: input.relation_type
+    }
+  });
+  const relationId = mutationEntityId(
+    payload.issueRelationCreate,
+    "issueRelation",
+    "linear create_linear_issue_relation \u5931\u8D25"
+  );
+  const relation = await fetchIssueRelationById(ctx, relationId);
+  return {
+    id: relation.id,
+    issue_id: asRecord(relation.issue)?.id ?? input.issue_id,
+    related_issue_id: asRecord(relation.relatedIssue)?.id ?? input.related_issue_id,
+    relation_type: relation.type ?? input.relation_type
+  };
+}
+async function createLinearLabel(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateIssueLabel($input: IssueLabelCreateInput!) {
+      issueLabelCreate(input: $input) {
+        success
+        issueLabel {
+          id
+        }
+      }
+    }
+  `, {
+    input: compact({
+      teamId: input.team_id,
+      name: input.name,
+      color: input.color,
+      description: str(input.description)
+    })
+  });
+  const labelId = mutationEntityId(payload.issueLabelCreate, "issueLabel", "linear create_linear_label \u5931\u8D25");
+  const label = await fetchIssueLabelById(ctx, labelId);
+  return {
+    id: label.id,
+    team_id: asRecord(label.team)?.id ?? input.team_id,
+    name: label.name,
+    color: label.color ?? input.color,
+    description: label.description ?? null
+  };
+}
+async function createLinearProject(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateProject($input: ProjectCreateInput!) {
+      projectCreate(input: $input) {
+        success
+        project {
+          id
+        }
+      }
+    }
+  `, {
+    // 入参声明里还有 `status_id` 与 `state`,上游**不往 create 里发**(只有 update 认它们)。
+    // 保留这个取舍:替上游发一个没验证过的字段,失败方式会比"这个字段没生效"更难查。
+    input: compact({
+      icon: str(input.icon),
+      name: input.name,
+      color: str(input.color),
+      leadId: str(input.lead_id),
+      priority: input.priority,
+      teamIds: input.team_ids,
+      startDate: str(input.start_date),
+      description: str(input.description),
+      targetDate: str(input.target_date)
+    })
+  });
+  const projectId = mutationEntityId(payload.projectCreate, "project", "linear create_linear_project \u5931\u8D25");
+  const project = await fetchProjectById(ctx, projectId, false, false, false);
+  return { id: project.id, name: project.name, url: project.url, state: project.state };
+}
+async function createProjectMilestone(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateProjectMilestone($input: ProjectMilestoneCreateInput!) {
+      projectMilestoneCreate(input: $input) {
+        success
+        projectMilestone {
+          id
+        }
+      }
+    }
+  `, {
+    input: compact({
+      name: input.name,
+      projectId: input.project_id,
+      sortOrder: input.sort_order,
+      description: str(input.description),
+      targetDate: str(input.target_date)
+    })
+  });
+  const milestoneId = mutationEntityId(
+    payload.projectMilestoneCreate,
+    "projectMilestone",
+    "linear create_project_milestone \u5931\u8D25"
+  );
+  const milestone = await fetchProjectMilestoneById(ctx, milestoneId);
+  return {
+    id: milestone.id,
+    project_id: asRecord(milestone.project)?.id ?? input.project_id,
+    name: milestone.name,
+    target_date: milestone.targetDate ?? null
+  };
+}
+async function createProjectUpdate(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation CreateProjectUpdate($input: ProjectUpdateCreateInput!) {
+      projectUpdateCreate(input: $input) {
+        success
+        projectUpdate {
+          id
+        }
+      }
+    }
+  `, {
+    input: compact({
+      body: input.body,
+      health: str(input.health),
+      projectId: input.project_id,
+      isDiffHidden: input.is_diff_hidden
+    })
+  });
+  const projectUpdateId = mutationEntityId(
+    payload.projectUpdateCreate,
+    "projectUpdate",
+    "linear create_project_update \u5931\u8D25"
+  );
+  const projectUpdate = await fetchProjectUpdateById(ctx, projectUpdateId);
+  return {
+    id: projectUpdate.id,
+    project_id: asRecord(projectUpdate.project)?.id ?? input.project_id,
+    body: projectUpdate.body ?? null,
+    health: projectUpdate.health ?? null,
+    is_diff_hidden: Boolean(projectUpdate.isDiffHidden)
+  };
+}
+async function deleteLinearIssue(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation DeleteIssue($id: String!) {
+      issueDelete(id: $id) {
+        success
+        entity {
+          id
+        }
+      }
+    }
+  `, { id: input.issue_id });
+  return { id: archiveEntityId(payload.issueDelete, "linear delete_linear_issue \u5931\u8D25"), deleted: true };
+}
+var LIST_TEAMS_QUERY = `
+  query ListTeams($after: String) {
+    teams(after: $after, first: 100, includeArchived: false) {
+      nodes {
+        ${teamFields}
+      }
+      pageInfo {
+        ${pageInfoFields}
+      }
+    }
+  }
+`;
+async function getAllLinearTeams(_input, ctx) {
+  const teams = await fetchAllNodes(ctx, LIST_TEAMS_QUERY, (data) => data.teams);
+  return { teams: teams.map(mapTeam) };
+}
+async function getAttachment(input, ctx) {
+  const attachmentId = str(input.attachment_id);
+  const fileName = str(input.file_name);
+  if (attachmentId === void 0 && fileName === void 0) {
+    throw new TBError("invalid_argument", "linear attachment \u9700\u8981 attachment_id \u6216 file_name");
+  }
+  const attachments = await fetchIssueAttachments(ctx, input.issue_id);
+  const matched = attachments.find((item) => {
+    const attachment = asRecord(item);
+    if (attachmentId !== void 0 && attachment?.id === attachmentId) return true;
+    if (fileName !== void 0 && attachment?.title === fileName) return true;
+    return fileName !== void 0 && basenameFromUrl(String(attachment?.url ?? "")) === fileName;
+  });
+  if (matched === void 0) {
+    throw new TBError("invalid_argument", "linear \u5728\u8BE5 issue \u4E0B\u627E\u4E0D\u5230\u5339\u914D\u7684 attachment");
+  }
+  return { attachment: mapAttachment(matched) };
+}
+async function getCurrentUser(_input, ctx) {
+  return { viewer: mapUser(await fetchViewer(ctx)) };
+}
+async function getCyclesByTeamId(input, ctx) {
+  const cycles = await fetchTeamCycles(ctx, input.team_id);
+  return { cycles: cycles.map(mapCycle) };
+}
+async function getIssueDefaults(input, ctx) {
+  const data = await operation(ctx, `
+    query GetIssueDefaults($id: String!) {
+      team(id: $id) {
+        defaultIssueEstimate
+        defaultIssueState {
+          id
+          name
+        }
+      }
+    }
+  `, { id: input.team_id });
+  const team = requireEntity(data.team, "linear team \u4E0D\u5B58\u5728");
+  const defaultState = asRecord(team.defaultIssueState);
+  return {
+    team: {
+      defaultIssueState: defaultState === void 0 ? null : { id: String(defaultState.id), name: String(defaultState.name) },
+      defaultIssueEstimate: num(team.defaultIssueEstimate) ?? null
+    }
+  };
+}
+async function getLinearIssue(input, ctx) {
+  return { issue: mapDetailedIssue(await fetchIssueById(ctx, input.issue_id)) };
+}
+async function getLinearProject(input, ctx) {
+  const includeTeams = input.include_teams === true;
+  const includeMembers = input.include_members === true;
+  const includeInitiatives = input.include_initiatives === true;
+  const project = await fetchProjectById(ctx, input.project_id, includeTeams, includeMembers, includeInitiatives);
+  return { project: mapProject(project, { includeTeams, includeMembers, includeInitiatives }) };
+}
+async function listIssuesByTeamId(input, ctx) {
+  const payload = await operation(ctx, `
+    query ListIssuesByTeamId($id: String!, $after: String, $first: Int, $includeArchived: Boolean) {
+      team(id: $id) {
+        ${teamFields}
+        issues(after: $after, first: $first, includeArchived: $includeArchived) {
+          nodes {
+            ${issueFields}
+          }
+          pageInfo {
+            ${pageInfoFields}
+          }
+        }
+      }
+    }
+  `, {
+    id: input.team_id,
+    after: str(input.after),
+    first: input.first,
+    includeArchived: input.include_archived
+  });
+  const team = requireEntity(payload.team, "linear team \u4E0D\u5B58\u5728");
+  const issues = asRecord(team.issues);
+  return {
+    team: mapTeam(team),
+    issues: nodesOf(issues).map(mapIssueSummary),
+    // 只有这一个 action 的 page_info 是蛇形键,上游如此。
+    page_info: mapSnakePageInfo(issues?.pageInfo)
+  };
+}
+async function listIssueDrafts(input, ctx) {
+  const payload = await operation(ctx, `
+    query ListIssueDrafts($after: String, $first: Int) {
+      viewer {
+        drafts(after: $after, first: $first, includeArchived: false) {
+          nodes {
+            id
+            data
+            bodyData
+            createdAt
+            updatedAt
+            isAutogenerated
+            team {
+              ${teamFields}
+            }
+            issue {
+              id
+            }
+            project {
+              id
+            }
+            projectUpdate {
+              id
+            }
+            user {
+              ${userFields}
+            }
+          }
+          pageInfo {
+            ${pageInfoFields}
+          }
+        }
+      }
+    }
+  `, { after: str(input.after), first: input.first });
+  const drafts = asRecord(asRecord(payload.viewer)?.drafts);
+  return { drafts: nodesOf(drafts).map(mapDraft), page_info: mapPageInfo(drafts?.pageInfo) };
+}
+async function listLinearCycles(_input, ctx) {
+  const cycles = await fetchAllNodes(ctx, `
+    query ListCycles($after: String) {
+      cycles(after: $after, first: 100, includeArchived: false) {
+        nodes {
+          ${cycleFields}
+        }
+        pageInfo {
+          ${pageInfoFields}
+        }
+      }
+    }
+  `, (data) => data.cycles);
+  return { cycles: cycles.map(mapCycle) };
+}
+async function listLinearIssues(input, ctx) {
+  const assigneeId = await resolveAssigneeFilterId(ctx, str(input.assignee_id));
+  const payload = await operation(ctx, `
+    query ListLinearIssues($after: String, $first: Int, $filter: IssueFilter) {
+      issues(after: $after, first: $first, includeArchived: false, filter: $filter) {
+        nodes {
+          ${issueFields}
+        }
+        pageInfo {
+          ${pageInfoFields}
+        }
+      }
+    }
+  `, {
+    after: str(input.after),
+    first: input.first,
+    filter: buildIssuesFilter(str(input.project_id), assigneeId)
+  });
+  const issues = asRecord(payload.issues);
+  return { issues: nodesOf(issues).map(mapIssueSummary), page_info: mapPageInfo(issues?.pageInfo) };
+}
+async function listLinearLabels(input, ctx) {
+  const teamId = str(input.team_id);
+  const labels = teamId === void 0 ? await fetchAllNodes(ctx, `
+        query ListWorkspaceLabels($after: String) {
+          issueLabels(after: $after, first: 100, includeArchived: false) {
+            nodes {
+              ${labelFields}
+              team {
+                ${teamFields}
+              }
+            }
+            pageInfo {
+              ${pageInfoFields}
+            }
+          }
+        }
+      `, (data) => data.issueLabels) : await fetchTeamLabels(ctx, teamId);
+  return { labels: labels.map(mapLabel) };
+}
+async function listLinearProjects(_input, ctx) {
+  const projects = await fetchAllNodes(ctx, `
+    query ListProjects($after: String) {
+      projects(after: $after, first: 100, includeArchived: false) {
+        nodes {
+          ${projectFields}
+        }
+        pageInfo {
+          ${pageInfoFields}
+        }
+      }
+    }
+  `, (data) => data.projects);
+  return { projects: projects.map((project) => mapProject(project)) };
+}
+async function listLinearStates(input, ctx) {
+  const states = await fetchTeamStates(ctx, input.team_id);
+  return { states: states.map(mapWorkflowState) };
+}
+async function listLinearTeams(input, ctx) {
+  const teams = await fetchAllNodes(ctx, LIST_TEAMS_QUERY, (data) => data.teams);
+  const projectId = str(input.project_id);
+  const detailedTeams = await mapWithConcurrency(teams, 5, async (team) => {
+    const teamId = str(asRecord(team)?.id);
+    const detailed = teamId === void 0 ? asRecord(team) ?? {} : await fetchTeamDetails(ctx, teamId);
+    return {
+      ...mapTeam(detailed),
+      members: nodesOf(detailed.members).map(mapUser),
+      projects: nodesOf(detailed.projects).filter((project) => projectId === void 0 || String(asRecord(project)?.id) === projectId).map((project) => mapProject(project))
+    };
+  });
+  return { teams: detailedTeams };
+}
+async function listLinearUsers(input, ctx) {
+  const payload = await operation(ctx, `
+    query ListUsers($after: String, $first: Int) {
+      users(
+        after: $after
+        first: $first
+        includeArchived: false
+        includeDisabled: true
+      ) {
+        nodes {
+          ${userFields}
+        }
+        pageInfo {
+          ${pageInfoFields}
+        }
+      }
+    }
+  `, { after: str(input.after), first: input.first });
+  const users = asRecord(payload.users);
+  return { users: nodesOf(users).map(mapUser), page_info: mapPageInfo(users?.pageInfo) };
+}
+async function removeIssueLabel(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation RemoveIssueLabel($id: String!, $labelId: String!) {
+      issueRemoveLabel(id: $id, labelId: $labelId) {
+        success
+        issue {
+          id
+        }
+      }
+    }
+  `, { id: input.issue_id, labelId: input.label_id });
+  requireSuccess(payload.issueRemoveLabel, "linear remove_issue_label \u5931\u8D25");
+  return { issue_id: input.issue_id, label_id: input.label_id, removed: true };
+}
+async function removeReaction(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation RemoveReaction($id: String!) {
+      reactionDelete(id: $id) {
+        success
+        entityId
+      }
+    }
+  `, { id: input.reaction_id });
+  requireSuccess(payload.reactionDelete, "linear remove_reaction \u5931\u8D25");
+  return { reaction_id: input.reaction_id, removed: true };
+}
+async function runQuery(input, ctx) {
+  return rawDocument(ctx, input.query, input.variables);
+}
+async function runMutation(input, ctx) {
+  return rawDocument(ctx, input.mutation, input.variables);
+}
+async function searchIssues(input, ctx) {
+  const payload = await operation(ctx, `
+    query SearchIssues($after: String, $first: Int, $includeArchived: Boolean, $term: String!) {
+      searchIssues(
+        after: $after
+        first: $first
+        includeArchived: $includeArchived
+        term: $term
+      ) {
+        nodes {
+          ${issueFields}
+        }
+        pageInfo {
+          ${pageInfoFields}
+        }
+        totalCount
+      }
+    }
+  `, {
+    after: str(input.after),
+    first: input.first,
+    includeArchived: input.include_archived,
+    // 入参叫 query,GraphQL 变量叫 term —— 别顺手改名。
+    term: input.query
+  });
+  const results = asRecord(payload.searchIssues);
+  return {
+    issues: nodesOf(results).map(mapIssueSummary),
+    page_info: mapPageInfo(results?.pageInfo),
+    total_count: num(results?.totalCount) ?? 0
+  };
+}
+async function updateIssue(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+      issueUpdate(id: $id, input: $input) {
+        success
+        issue {
+          id
+        }
+      }
+    }
+  `, {
+    id: input.issueId,
+    input: compact({
+      title: str(input.title),
+      teamId: str(input.teamId),
+      cycleId: str(input.cycleId),
+      dueDate: str(input.dueDate),
+      stateId: str(input.stateId),
+      estimate: input.estimate,
+      labelIds: input.labelIds,
+      parentId: str(input.parentId),
+      priority: input.priority,
+      projectId: str(input.projectId),
+      assigneeId: str(input.assigneeId),
+      description: str(input.description)
+    })
+  });
+  const issueId = mutationEntityId(payload.issueUpdate, "issue", "linear update_issue \u5931\u8D25");
+  return { issue: mapDetailedIssue(await fetchIssueById(ctx, issueId)) };
+}
+async function updateLinearComment(input, ctx) {
+  const payload = await operation(ctx, `
+    mutation UpdateComment($id: String!, $input: CommentUpdateInput!) {
+      commentUpdate(id: $id, input: $input) {
+        success
+        comment {
+          id
+        }
+      }
+    }
+  `, { id: input.comment_id, input: { body: input.body } });
+  const commentId = mutationEntityId(payload.commentUpdate, "comment", "linear update_linear_comment \u5931\u8D25");
+  return { comment: mapComment(await fetchCommentById(ctx, commentId)) };
+}
+async function updateLinearProject(input, ctx) {
+  const requestedState = str(input.state);
+  const resolvedStatusId = str(input.status_id) ?? (requestedState === void 0 ? void 0 : await resolveProjectStatusId(ctx, requestedState));
+  const payload = await operation(ctx, `
+    mutation UpdateProject($id: String!, $input: ProjectUpdateInput!) {
+      projectUpdate(id: $id, input: $input) {
+        success
+        project {
+          id
+        }
+      }
+    }
+  `, {
+    id: input.project_id,
+    input: compact({
+      icon: str(input.icon),
+      name: str(input.name),
+      color: str(input.color),
+      leadId: str(input.lead_id),
+      priority: input.priority,
+      statusId: resolvedStatusId,
+      startDate: str(input.start_date),
+      description: str(input.description),
+      targetDate: str(input.target_date)
+    })
+  });
+  const projectId = mutationEntityId(payload.projectUpdate, "project", "linear update_linear_project \u5931\u8D25");
+  return { project: mapProject(await fetchProjectById(ctx, projectId, false, false, false)) };
+}
+
+// ../plugins/src/linear/schema.ts
+var createAttachmentInput = external_exports.strictObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID."),
+  title: external_exports.string().min(1).describe("Attachment title."),
+  url: external_exports.string().min(1).describe("Attachment URL."),
+  subtitle: external_exports.string().describe("Attachment subtitle.").optional()
+}).describe("The input payload for this action.");
+var createAttachmentOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  issue_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  title: external_exports.string().describe("Attachment title.").optional(),
+  url: external_exports.string().describe("Attachment URL.").optional(),
+  subtitle: external_exports.string().describe("Attachment subtitle.").nullable().optional()
+}).describe("Linear action output.");
+var createCommentReactionInput = external_exports.strictObject({
+  comment_id: external_exports.string().min(1).describe("Linear resource ID."),
+  emoji: external_exports.string().min(1).describe("Emoji to add.")
+}).describe("The input payload for this action.");
+var createCommentReactionOutput = external_exports.looseObject({
+  reaction_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  comment_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  emoji: external_exports.string().optional()
+}).describe("Linear action output.");
+var createLinearCommentInput = external_exports.strictObject({
+  issueId: external_exports.string().min(1).describe("Linear resource ID."),
+  body: external_exports.string().min(1).describe("Comment text in Markdown.")
+}).describe("The input payload for this action.");
+var createLinearCommentOutput = external_exports.looseObject({
+  comment_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  issue_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  body: external_exports.string().optional()
+}).describe("Linear action output.");
+var createLinearIssueInput = external_exports.strictObject({
+  title: external_exports.string().min(1).describe("Issue title."),
+  team_id: external_exports.string().min(1).describe("Linear resource ID."),
+  cycle_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  due_date: external_exports.string().describe("Issue due date.").optional(),
+  estimate: external_exports.number().describe("Issue estimate.").optional(),
+  priority: external_exports.number().describe("Issue priority.").optional(),
+  state_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  label_ids: external_exports.array(external_exports.string().min(1).describe("Linear resource ID.")).describe("Label IDs.").optional(),
+  parent_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  project_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  assignee_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  description: external_exports.string().describe("Issue description in Markdown.").optional()
+}).describe("The input payload for this action.");
+var createLinearIssueOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  identifier: external_exports.string().describe("Issue identifier.").optional(),
+  issue_title: external_exports.string().describe("Issue title.").optional(),
+  issue_description: external_exports.string().describe("Issue description.").nullable().optional(),
+  ticket_url: external_exports.string().describe("Issue URL.").optional()
+}).describe("Linear action output.");
+var createLinearIssueRelationInput = external_exports.strictObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID."),
+  related_issue_id: external_exports.string().min(1).describe("Linear resource ID."),
+  relation_type: external_exports.enum(["blocks", "duplicate", "related", "similar"]).describe("Relationship type.")
+}).describe("The input payload for this action.");
+var createLinearIssueRelationOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  issue_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  related_issue_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  relation_type: external_exports.string().optional()
+}).describe("Linear action output.");
+var createLinearLabelInput = external_exports.strictObject({
+  team_id: external_exports.string().min(1).describe("Linear resource ID."),
+  name: external_exports.string().min(1).describe("Label name."),
+  color: external_exports.string().min(1).describe("Label color."),
+  description: external_exports.string().describe("Label description.").optional()
+}).describe("The input payload for this action.");
+var createLinearLabelOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  team_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  name: external_exports.string().optional(),
+  color: external_exports.string().optional(),
+  description: external_exports.string().nullable().optional()
+}).describe("Linear action output.");
+var createLinearProjectInput = external_exports.strictObject({
+  icon: external_exports.string().describe("Project icon.").optional(),
+  name: external_exports.string().min(1).describe("Project name."),
+  color: external_exports.string().describe("Project color.").optional(),
+  lead_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  priority: external_exports.number().describe("Project priority.").optional(),
+  status_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  state: external_exports.string().describe("Project state type.").optional(),
+  start_date: external_exports.string().describe("Project start date.").optional(),
+  description: external_exports.string().describe("Project description.").optional(),
+  target_date: external_exports.string().describe("Project target date.").optional(),
+  team_ids: external_exports.array(external_exports.string().min(1).describe("Linear resource ID.")).min(1).describe("Team IDs associated with the project.")
+}).describe("The input payload for this action.");
+var createLinearProjectOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  name: external_exports.string().optional(),
+  url: external_exports.string().optional(),
+  state: external_exports.string().optional()
+}).describe("Linear action output.");
+var createProjectMilestoneInput = external_exports.strictObject({
+  name: external_exports.string().min(1).describe("Milestone name."),
+  project_id: external_exports.string().min(1).describe("Linear resource ID."),
+  sort_order: external_exports.number().describe("Milestone sort order.").optional(),
+  description: external_exports.string().describe("Milestone description.").optional(),
+  target_date: external_exports.string().describe("Target date.").optional()
+}).describe("The input payload for this action.");
+var createProjectMilestoneOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  project_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  name: external_exports.string().optional(),
+  target_date: external_exports.string().nullable().optional()
+}).describe("Linear action output.");
+var createProjectUpdateInput = external_exports.strictObject({
+  body: external_exports.string().min(1).describe("Project update body."),
+  health: external_exports.enum(["onTrack", "atRisk", "offTrack"]).describe("Project health.").optional(),
+  project_id: external_exports.string().min(1).describe("Linear resource ID."),
+  is_diff_hidden: external_exports.boolean().describe("Whether to hide diff.").optional()
+}).describe("The input payload for this action.");
+var createProjectUpdateOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  project_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  body: external_exports.string().nullable().optional(),
+  health: external_exports.string().nullable().optional(),
+  is_diff_hidden: external_exports.boolean().optional()
+}).describe("Linear action output.");
+var deleteLinearIssueInput = external_exports.strictObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var deleteLinearIssueOutput = external_exports.looseObject({
+  id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  deleted: external_exports.boolean().optional()
+}).describe("Linear action output.");
+var getAllLinearTeamsInput = external_exports.strictObject({}).describe("The input payload for this action.");
+var getAllLinearTeamsOutput = external_exports.looseObject({
+  teams: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("teams returned by Linear.").optional()
+}).describe("Linear action output.");
+var getAttachmentInput = external_exports.strictObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID."),
+  attachment_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  file_name: external_exports.string().min(1).describe("Attachment file name or title.").optional()
+}).describe("The input payload for this action.");
+var getAttachmentOutput = external_exports.looseObject({
+  attachment: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var getCurrentUserInput = external_exports.strictObject({}).describe("The input payload for this action.");
+var getCurrentUserOutput = external_exports.looseObject({
+  viewer: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var getCyclesByTeamIdInput = external_exports.strictObject({
+  team_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var getCyclesByTeamIdOutput = external_exports.looseObject({
+  cycles: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("cycles returned by Linear.").optional()
+}).describe("Linear action output.");
+var getIssueDefaultsInput = external_exports.strictObject({
+  team_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var getIssueDefaultsOutput = external_exports.looseObject({
+  team: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var getLinearIssueInput = external_exports.strictObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var getLinearIssueOutput = external_exports.looseObject({
+  issue: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var getLinearProjectInput = external_exports.strictObject({
+  project_id: external_exports.string().min(1).describe("Linear resource ID."),
+  include_teams: external_exports.boolean().describe("Include project teams.").optional(),
+  include_members: external_exports.boolean().describe("Include project members.").optional(),
+  include_initiatives: external_exports.boolean().describe("Include project initiatives.").optional()
+}).describe("The input payload for this action.");
+var getLinearProjectOutput = external_exports.looseObject({
+  project: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var listIssuesByTeamIdInput = external_exports.strictObject({
+  after: external_exports.string().describe("Pagination cursor.").optional(),
+  first: external_exports.int().min(1).describe("Number of records to return.").optional(),
+  team_id: external_exports.string().min(1).describe("Linear resource ID."),
+  include_archived: external_exports.boolean().describe("Include archived issues.").optional()
+}).describe("The input payload for this action.");
+var listIssuesByTeamIdOutput = external_exports.looseObject({
+  team: external_exports.looseObject({}).describe("Linear API object.").optional(),
+  issues: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).optional(),
+  page_info: external_exports.looseObject({
+    startCursor: external_exports.string().describe("Previous-page start cursor.").nullable().optional(),
+    endCursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    hasPreviousPage: external_exports.boolean().describe("Whether a previous page exists.").optional(),
+    hasNextPage: external_exports.boolean().describe("Whether a next page exists.").optional(),
+    end_cursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    has_next_page: external_exports.boolean().describe("Whether a next page exists.").optional()
+  }).describe("Pagination information.").optional()
+}).describe("Linear action output.");
+var listIssueDraftsInput = external_exports.strictObject({
+  after: external_exports.string().describe("Pagination cursor.").optional(),
+  first: external_exports.int().min(1).describe("Number of records to return.").optional()
+}).describe("The input payload for this action.");
+var listIssueDraftsOutput = external_exports.looseObject({
+  drafts: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).optional(),
+  page_info: external_exports.looseObject({
+    startCursor: external_exports.string().describe("Previous-page start cursor.").nullable().optional(),
+    endCursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    hasPreviousPage: external_exports.boolean().describe("Whether a previous page exists.").optional(),
+    hasNextPage: external_exports.boolean().describe("Whether a next page exists.").optional(),
+    end_cursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    has_next_page: external_exports.boolean().describe("Whether a next page exists.").optional()
+  }).describe("Pagination information.").optional()
+}).describe("Linear action output.");
+var listLinearCyclesInput = external_exports.strictObject({}).describe("The input payload for this action.");
+var listLinearCyclesOutput = external_exports.looseObject({
+  cycles: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("cycles returned by Linear.").optional()
+}).describe("Linear action output.");
+var listLinearIssuesInput = external_exports.strictObject({
+  after: external_exports.string().describe("Pagination cursor.").optional(),
+  first: external_exports.int().min(1).describe("Number of records to return.").optional(),
+  project_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  assignee_id: external_exports.string().min(1).describe("Linear resource ID.").optional()
+}).describe("The input payload for this action.");
+var listLinearIssuesOutput = external_exports.looseObject({
+  issues: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).optional(),
+  page_info: external_exports.looseObject({
+    startCursor: external_exports.string().describe("Previous-page start cursor.").nullable().optional(),
+    endCursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    hasPreviousPage: external_exports.boolean().describe("Whether a previous page exists.").optional(),
+    hasNextPage: external_exports.boolean().describe("Whether a next page exists.").optional(),
+    end_cursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    has_next_page: external_exports.boolean().describe("Whether a next page exists.").optional()
+  }).describe("Pagination information.").optional()
+}).describe("Linear action output.");
+var listLinearLabelsInput = external_exports.strictObject({
+  team_id: external_exports.string().min(1).describe("Linear resource ID.").optional()
+}).describe("The input payload for this action.");
+var listLinearLabelsOutput = external_exports.looseObject({
+  labels: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("labels returned by Linear.").optional()
+}).describe("Linear action output.");
+var listLinearProjectsInput = external_exports.strictObject({}).describe("The input payload for this action.");
+var listLinearProjectsOutput = external_exports.looseObject({
+  projects: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("projects returned by Linear.").optional()
+}).describe("Linear action output.");
+var listLinearStatesInput = external_exports.strictObject({
+  team_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var listLinearStatesOutput = external_exports.looseObject({
+  states: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("states returned by Linear.").optional()
+}).describe("Linear action output.");
+var listLinearTeamsInput = external_exports.strictObject({
+  project_id: external_exports.string().min(1).describe("Linear resource ID.").optional()
+}).describe("The input payload for this action.");
+var listLinearTeamsOutput = external_exports.looseObject({
+  teams: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("teams returned by Linear.").optional()
+}).describe("Linear action output.");
+var listLinearUsersInput = external_exports.strictObject({
+  after: external_exports.string().describe("Pagination cursor.").optional(),
+  first: external_exports.int().min(1).describe("Number of records to return.").optional()
+}).describe("The input payload for this action.");
+var listLinearUsersOutput = external_exports.looseObject({
+  users: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).optional(),
+  page_info: external_exports.looseObject({
+    startCursor: external_exports.string().describe("Previous-page start cursor.").nullable().optional(),
+    endCursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    hasPreviousPage: external_exports.boolean().describe("Whether a previous page exists.").optional(),
+    hasNextPage: external_exports.boolean().describe("Whether a next page exists.").optional(),
+    end_cursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    has_next_page: external_exports.boolean().describe("Whether a next page exists.").optional()
+  }).describe("Pagination information.").optional()
+}).describe("Linear action output.");
+var removeIssueLabelInput = external_exports.strictObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID."),
+  label_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var removeIssueLabelOutput = external_exports.looseObject({
+  issue_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  label_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  removed: external_exports.boolean().optional()
+}).describe("Linear action output.");
+var removeReactionInput = external_exports.strictObject({
+  reaction_id: external_exports.string().min(1).describe("Linear resource ID.")
+}).describe("The input payload for this action.");
+var removeReactionOutput = external_exports.looseObject({
+  reaction_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  removed: external_exports.boolean().optional()
+}).describe("Linear action output.");
+var runQueryInput = external_exports.strictObject({
+  query: external_exports.string().min(1),
+  variables: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("The input payload for this action.");
+var runQueryOutput = external_exports.looseObject({
+  data: external_exports.looseObject({}).describe("Linear API object.").nullable().optional(),
+  errors: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("GraphQL errors.").optional(),
+  extensions: external_exports.looseObject({}).describe("Linear API object.").optional(),
+  message: external_exports.string().describe("Summarized execution status.").optional()
+}).describe("Raw GraphQL response.");
+var runMutationInput = external_exports.strictObject({
+  mutation: external_exports.string().min(1),
+  variables: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("The input payload for this action.");
+var runMutationOutput = external_exports.looseObject({
+  data: external_exports.looseObject({}).describe("Linear API object.").nullable().optional(),
+  errors: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).describe("GraphQL errors.").optional(),
+  extensions: external_exports.looseObject({}).describe("Linear API object.").optional(),
+  message: external_exports.string().describe("Summarized execution status.").optional()
+}).describe("Raw GraphQL response.");
+var searchIssuesInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Search query."),
+  after: external_exports.string().describe("Pagination cursor.").optional(),
+  first: external_exports.int().min(1).describe("Number of records to return.").optional(),
+  include_archived: external_exports.boolean().describe("Include archived issues.").optional()
+}).describe("The input payload for this action.");
+var searchIssuesOutput = external_exports.looseObject({
+  issues: external_exports.array(external_exports.looseObject({}).describe("Linear API object.")).optional(),
+  page_info: external_exports.looseObject({
+    startCursor: external_exports.string().describe("Previous-page start cursor.").nullable().optional(),
+    endCursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    hasPreviousPage: external_exports.boolean().describe("Whether a previous page exists.").optional(),
+    hasNextPage: external_exports.boolean().describe("Whether a next page exists.").optional(),
+    end_cursor: external_exports.string().describe("Next-page end cursor.").nullable().optional(),
+    has_next_page: external_exports.boolean().describe("Whether a next page exists.").optional()
+  }).describe("Pagination information.").optional(),
+  total_count: external_exports.int().optional()
+}).describe("Linear action output.");
+var updateIssueInput = external_exports.strictObject({
+  issueId: external_exports.string().min(1).describe("Linear resource ID."),
+  title: external_exports.string().describe("Issue title.").optional(),
+  teamId: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  cycleId: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  dueDate: external_exports.string().describe("Issue due date.").optional(),
+  stateId: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  estimate: external_exports.number().describe("Issue estimate.").optional(),
+  labelIds: external_exports.array(external_exports.string().min(1).describe("Linear resource ID.")).describe("Label IDs.").optional(),
+  parentId: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  priority: external_exports.number().describe("Issue priority.").optional(),
+  projectId: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  assigneeId: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  description: external_exports.string().describe("Issue description in Markdown.").optional()
+}).describe("The input payload for this action.");
+var updateIssueOutput = external_exports.looseObject({
+  issue: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var updateLinearCommentInput = external_exports.strictObject({
+  comment_id: external_exports.string().min(1).describe("Linear resource ID."),
+  body: external_exports.string().min(1)
+}).describe("The input payload for this action.");
+var updateLinearCommentOutput = external_exports.looseObject({
+  comment: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var updateLinearProjectInput = external_exports.strictObject({
+  project_id: external_exports.string().min(1).describe("Linear resource ID."),
+  icon: external_exports.string().describe("Project icon.").optional(),
+  name: external_exports.string().min(1).describe("Project name.").optional(),
+  color: external_exports.string().describe("Project color.").optional(),
+  lead_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  priority: external_exports.number().describe("Project priority.").optional(),
+  status_id: external_exports.string().min(1).describe("Linear resource ID.").optional(),
+  state: external_exports.string().describe("Project state type.").optional(),
+  start_date: external_exports.string().describe("Project start date.").optional(),
+  description: external_exports.string().describe("Project description.").optional(),
+  target_date: external_exports.string().describe("Project target date.").optional()
+}).describe("The input payload for this action.");
+var updateLinearProjectOutput = external_exports.looseObject({
+  project: external_exports.looseObject({}).describe("Linear API object.").optional()
+}).describe("Linear action output.");
+var linearActions = {
+  create_attachment: {
+    description: "Create or update an attachment for the specified Linear issue.",
+    effect: "write",
+    inputSchema: createAttachmentInput,
+    outputSchema: external_exports.toJSONSchema(createAttachmentOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_comment_reaction: {
+    description: "Creates an emoji reaction for the specified Linear comment.",
+    effect: "write",
+    inputSchema: createCommentReactionInput,
+    outputSchema: external_exports.toJSONSchema(createCommentReactionOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_linear_comment: {
+    description: "Creates a comment for the specified Linear issue.",
+    effect: "write",
+    inputSchema: createLinearCommentInput,
+    outputSchema: external_exports.toJSONSchema(createLinearCommentOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_linear_issue: {
+    description: "Create a new Linear issue in the specified team and support fields such as project, person in charge, status, label, etc.",
+    effect: "write",
+    inputSchema: createLinearIssueInput,
+    outputSchema: external_exports.toJSONSchema(createLinearIssueOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_linear_issue_relation: {
+    description: "Create a relationship between two Linear issues, such as blocks, related, or duplicate.",
+    effect: "write",
+    inputSchema: createLinearIssueRelationInput,
+    outputSchema: external_exports.toJSONSchema(createLinearIssueRelationOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_linear_label: {
+    description: "Creates a new Linear issue label in the specified team.",
+    effect: "write",
+    inputSchema: createLinearLabelInput,
+    outputSchema: external_exports.toJSONSchema(createLinearLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_linear_project: {
+    description: "Create a new Linear project and associate one or more teams.",
+    effect: "write",
+    inputSchema: createLinearProjectInput,
+    outputSchema: external_exports.toJSONSchema(createLinearProjectOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_project_milestone: {
+    description: "Creates a project milestone for the specified Linear project.",
+    effect: "write",
+    inputSchema: createProjectMilestoneInput,
+    outputSchema: external_exports.toJSONSchema(createProjectMilestoneOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_project_update: {
+    description: "Creates a project progress update for the specified Linear project.",
+    effect: "write",
+    inputSchema: createProjectUpdateInput,
+    outputSchema: external_exports.toJSONSchema(createProjectUpdateOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_linear_issue: {
+    description: "Delete the specified Linear issue.",
+    effect: "destructive",
+    inputSchema: deleteLinearIssueInput,
+    outputSchema: external_exports.toJSONSchema(deleteLinearIssueOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_all_linear_teams: {
+    description: "Lists all Linear team basic information accessible with the current credentials.",
+    effect: "read",
+    inputSchema: getAllLinearTeamsInput,
+    outputSchema: external_exports.toJSONSchema(getAllLinearTeamsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_attachment: {
+    description: "Retrieve a Linear attachment based on the issue and attachment ID or file name.",
+    effect: "read",
+    inputSchema: getAttachmentInput,
+    outputSchema: external_exports.toJSONSchema(getAttachmentOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_current_user: {
+    description: "Get the currently authenticated Linear user profile.",
+    effect: "read",
+    inputSchema: getCurrentUserInput,
+    outputSchema: external_exports.toJSONSchema(getCurrentUserOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_cycles_by_team_id: {
+    description: "Get all cycle information under the specified team.",
+    effect: "read",
+    inputSchema: getCyclesByTeamIdInput,
+    outputSchema: external_exports.toJSONSchema(getCyclesByTeamIdOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_issue_defaults: {
+    description: "Gets the default status and default estimate used when the specified team creates an issue.",
+    effect: "read",
+    inputSchema: getIssueDefaultsInput,
+    outputSchema: external_exports.toJSONSchema(getIssueDefaultsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_linear_issue: {
+    description: "Get details of a Linear issue, including comments, attachments, subscribers, and underlying relationship fields.",
+    effect: "read",
+    inputSchema: getLinearIssueInput,
+    outputSchema: external_exports.toJSONSchema(getLinearIssueOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_linear_project: {
+    description: "Get the details of a Linear project, complete with team, members, and initiatives on demand.",
+    effect: "read",
+    inputSchema: getLinearProjectInput,
+    outputSchema: external_exports.toJSONSchema(getLinearProjectOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_issues_by_team_id: {
+    description: "List Linear issues by team, and support cursor paging and whether to include archived issues.",
+    effect: "read",
+    inputSchema: listIssuesByTeamIdInput,
+    outputSchema: external_exports.toJSONSchema(listIssuesByTeamIdOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_issue_drafts: {
+    description: "Lists issue drafts visible to the current user in Linear.",
+    effect: "read",
+    inputSchema: listIssueDraftsInput,
+    outputSchema: external_exports.toJSONSchema(listIssueDraftsOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_cycles: {
+    description: "Lists the Linear periods accessible by the current credential.",
+    effect: "read",
+    inputSchema: listLinearCyclesInput,
+    outputSchema: external_exports.toJSONSchema(listLinearCyclesOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_issues: {
+    description: "Lists Linear issues accessible with current credentials, and supports filtering by project and person in charge.",
+    effect: "read",
+    inputSchema: listLinearIssuesInput,
+    outputSchema: external_exports.toJSONSchema(listLinearIssuesOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_labels: {
+    description: "Lists Linear labels for a specified team or entire workspace.",
+    effect: "read",
+    inputSchema: listLinearLabelsInput,
+    outputSchema: external_exports.toJSONSchema(listLinearLabelsOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_projects: {
+    description: "Lists Linear projects accessible with the current credentials.",
+    effect: "read",
+    inputSchema: listLinearProjectsInput,
+    outputSchema: external_exports.toJSONSchema(listLinearProjectsOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_states: {
+    description: "Lists all workflow statuses for the specified team.",
+    effect: "read",
+    inputSchema: listLinearStatesInput,
+    outputSchema: external_exports.toJSONSchema(listLinearStatesOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_teams: {
+    description: "Lists Linear teams accessible with current credentials, along with a list of members and projects.",
+    effect: "read",
+    inputSchema: listLinearTeamsInput,
+    outputSchema: external_exports.toJSONSchema(listLinearTeamsOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_linear_users: {
+    description: "List Linear users in the current workspace and support cursor paging.",
+    effect: "read",
+    inputSchema: listLinearUsersInput,
+    outputSchema: external_exports.toJSONSchema(listLinearUsersOutput, { io: "output", unrepresentable: "any" })
+  },
+  remove_issue_label: {
+    description: "Removes a label from the specified Linear issue.",
+    effect: "destructive",
+    inputSchema: removeIssueLabelInput,
+    outputSchema: external_exports.toJSONSchema(removeIssueLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  remove_reaction: {
+    description: "Delete an existing Linear reaction.",
+    effect: "destructive",
+    inputSchema: removeReactionInput,
+    outputSchema: external_exports.toJSONSchema(removeReactionOutput, { io: "output", unrepresentable: "any" })
+  },
+  run_query: {
+    description: "Execute a read-only query directly against the Linear GraphQL API.",
+    effect: "write",
+    inputSchema: runQueryInput,
+    outputSchema: external_exports.toJSONSchema(runQueryOutput, { io: "output", unrepresentable: "any" })
+  },
+  run_mutation: {
+    description: "Perform a mutation directly on the Linear GraphQL API.",
+    effect: "write",
+    inputSchema: runMutationInput,
+    outputSchema: external_exports.toJSONSchema(runMutationOutput, { io: "output", unrepresentable: "any" })
+  },
+  search_issues: {
+    description: "Retrieve issues through Linear's full-text search capabilities.",
+    effect: "read",
+    inputSchema: searchIssuesInput,
+    outputSchema: external_exports.toJSONSchema(searchIssuesOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_issue: {
+    description: "Update an existing Linear issue and support fields such as title, description, status, project, label, etc.",
+    effect: "write",
+    inputSchema: updateIssueInput,
+    outputSchema: external_exports.toJSONSchema(updateIssueOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_linear_comment: {
+    description: "Update the text of an existing Linear comment.",
+    effect: "write",
+    inputSchema: updateLinearCommentInput,
+    outputSchema: external_exports.toJSONSchema(updateLinearCommentOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_linear_project: {
+    description: "Update an existing Linear project.",
+    effect: "write",
+    inputSchema: updateLinearProjectInput,
+    outputSchema: external_exports.toJSONSchema(updateLinearProjectOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/linear/index.ts
+function createLinearPlugin() {
+  return createProviderPlugin({
+    description: "Linear",
+    actions: linearActions,
+    // 上游两个 credentialValidators(apiKey 与 oauth2)都打 `viewer` 查询 —— 只读、
+    // 入参 schema 是空对象,正好当挂载时的凭证探针。
+    credentialProbe: "get_current_user",
+    handlers: {
+      create_attachment: createAttachment,
+      create_comment_reaction: createCommentReaction,
+      create_linear_comment: createLinearComment,
+      create_linear_issue: createLinearIssue,
+      create_linear_issue_relation: createLinearIssueRelation,
+      create_linear_label: createLinearLabel,
+      create_linear_project: createLinearProject,
+      create_project_milestone: createProjectMilestone,
+      create_project_update: createProjectUpdate,
+      delete_linear_issue: deleteLinearIssue,
+      get_all_linear_teams: getAllLinearTeams,
+      get_attachment: getAttachment,
+      get_current_user: getCurrentUser,
+      get_cycles_by_team_id: getCyclesByTeamId,
+      get_issue_defaults: getIssueDefaults,
+      get_linear_issue: getLinearIssue,
+      get_linear_project: getLinearProject,
+      list_issue_drafts: listIssueDrafts,
+      list_issues_by_team_id: listIssuesByTeamId,
+      list_linear_cycles: listLinearCycles,
+      list_linear_issues: listLinearIssues,
+      list_linear_labels: listLinearLabels,
+      list_linear_projects: listLinearProjects,
+      list_linear_states: listLinearStates,
+      list_linear_teams: listLinearTeams,
+      list_linear_users: listLinearUsers,
+      remove_issue_label: removeIssueLabel,
+      remove_reaction: removeReaction,
+      run_mutation: runMutation,
+      run_query: runQuery,
+      search_issues: searchIssues,
+      update_issue: updateIssue,
+      update_linear_comment: updateLinearComment,
+      update_linear_project: updateLinearProject
+    }
+  });
+}
+var linear_default = createLinearPlugin();
+export {
+  createLinearPlugin,
+  linear_default as default
+};