@bike4mind/cli 0.2.30-subagent-delegation.19188 → 0.2.30

package/dist/{chunk-ICLEQOH6.js → chunk-T4VPCTBM.js}

@@ -171,6 +171,20 @@ var ChatModels;
 })(ChatModels || (ChatModels = {}));
 var CHAT_MODELS = Object.values(ChatModels);
 var supportedChatModels = z.nativeEnum(ChatModels);
+var REASONING_SUPPORTED_MODELS = /* @__PURE__ */ new Set([
+  ChatModels.O1,
+  ChatModels.O3_MINI,
+  ChatModels.O3,
+  ChatModels.O4_MINI,
+  ChatModels.GPT5,
+  ChatModels.GPT5_MINI,
+  ChatModels.GPT5_NANO,
+  ChatModels.GPT5_CHAT_LATEST,
+  ChatModels.GPT5_1,
+  ChatModels.GPT5_1_CHAT_LATEST,
+  ChatModels.GPT5_2,
+  ChatModels.GPT5_2_CHAT_LATEST
+]);
 var SpeechToTextModels;
 (function(SpeechToTextModels2) {
   SpeechToTextModels2["WHISPER_1"] = "whisper-1";
@@ -310,9 +324,7 @@ var b4mLLMTools = z5.enum([
   "iss_tracker",
   "planet_visibility",
   // Knowledge base search
-  "search_knowledge_base",
-  // Agent delegation
-  "delegate_to_agent"
+  "search_knowledge_base"
 ]);
 var B4MLLMToolsList = b4mLLMTools.options.map((tool) => tool);
 var RechartsChartTypeSchema = z5.enum([
@@ -1063,6 +1075,25 @@ var WebhookDeliveryStatus;
   WebhookDeliveryStatus2["Pending"] = "pending";
 })(WebhookDeliveryStatus || (WebhookDeliveryStatus = {}));
 
+// ../../b4m-core/packages/common/dist/src/types/entities/JiraWebhookConfigTypes.js
+var COMMON_JIRA_WEBHOOK_EVENTS = [
+  "jira:issue_created",
+  "jira:issue_updated",
+  "comment_created",
+  "comment_updated",
+  "sprint_started",
+  "sprint_closed"
+];
+
+// ../../b4m-core/packages/common/dist/src/types/entities/JiraWebhookDeliveryTypes.js
+var JiraWebhookDeliveryStatus;
+(function(JiraWebhookDeliveryStatus2) {
+  JiraWebhookDeliveryStatus2["Success"] = "success";
+  JiraWebhookDeliveryStatus2["Failed"] = "failed";
+  JiraWebhookDeliveryStatus2["Filtered"] = "filtered";
+  JiraWebhookDeliveryStatus2["Pending"] = "pending";
+})(JiraWebhookDeliveryStatus || (JiraWebhookDeliveryStatus = {}));
+
 // ../../b4m-core/packages/common/dist/src/types/common.js
 var SupportedFabFileMimeTypes;
 (function(SupportedFabFileMimeTypes2) {
@@ -7258,6 +7289,632 @@ var AgileApi = class {
   }
 };
 
+// ../../b4m-core/packages/common/dist/src/jira/webhook/format.js
+function daysUntil(dateString) {
+  const expirationDate = new Date(dateString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = expirationDate.getTime() - now.getTime();
+  return Math.ceil(diffMs / (1e3 * 60 * 60 * 24));
+}
+function formatWebhook(webhook) {
+  const daysUntilExpiry = daysUntil(webhook.expirationDate);
+  return {
+    id: webhook.id,
+    events: webhook.events,
+    jqlFilter: webhook.jqlFilter,
+    expirationDate: webhook.expirationDate,
+    daysUntilExpiry,
+    isExpiringSoon: daysUntilExpiry < 7
+  };
+}
+function formatWebhookList(response) {
+  return {
+    webhooks: response.values.map(formatWebhook),
+    total: response.total,
+    hasMore: !response.isLast
+  };
+}
+function extractAdfText(body, maxLength = 500) {
+  if (!body || typeof body !== "object")
+    return "";
+  const doc = body;
+  if (doc.type !== "doc" || !Array.isArray(doc.content))
+    return "";
+  const parts = [];
+  let totalLength = 0;
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (totalLength >= maxLength)
+        return;
+      if (!node || typeof node !== "object")
+        continue;
+      const n = node;
+      if (n.type === "text" && typeof n.text === "string") {
+        const remaining = maxLength - totalLength;
+        const text = n.text.slice(0, remaining);
+        parts.push(text);
+        totalLength += text.length;
+      }
+      if (Array.isArray(n.content)) {
+        walk(n.content);
+      }
+    }
+  }
+  walk(doc.content);
+  const result = parts.join("");
+  if (totalLength >= maxLength)
+    return result + "...";
+  return result;
+}
+function escapeSlackMrkdwn(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\*/g, "\u2217").replace(/_/g, "\uFF3F").replace(/~/g, "\u223C").replace(/`/g, "\u02CB");
+}
+var PRIORITY_EMOJI = {
+  Highest: ":red_circle:",
+  High: ":large_orange_circle:",
+  Medium: ":large_yellow_circle:",
+  Low: ":large_green_circle:",
+  Lowest: ":white_circle:"
+};
+function getPriorityEmoji(priority) {
+  if (!priority)
+    return "";
+  return PRIORITY_EMOJI[priority] || ":blue_circle:";
+}
+function formatIssueEventForSlack(event, siteUrl) {
+  const { issue, webhookEvent, user, changelog } = event;
+  const { fields } = issue;
+  const priorityEmoji = getPriorityEmoji(fields.priority?.name);
+  const issueUrl = `${siteUrl}/browse/${issue.key}`;
+  let action;
+  let emoji;
+  switch (webhookEvent) {
+    case "jira:issue_created":
+      action = "created";
+      emoji = ":new:";
+      break;
+    case "jira:issue_updated":
+      action = "updated";
+      emoji = ":pencil2:";
+      break;
+    case "jira:issue_deleted":
+      action = "deleted";
+      emoji = ":wastebasket:";
+      break;
+    default:
+      action = "changed";
+      emoji = ":bell:";
+  }
+  let changelogText = "";
+  if (changelog?.items && changelog.items.length > 0) {
+    const changes = changelog.items.slice(0, 3).map((item) => {
+      const from = escapeSlackMrkdwn(item.fromString || "None");
+      const to = escapeSlackMrkdwn(item.toString || "None");
+      if (item.field === "status") {
+        return `Status: ${from} \u2192 ${to}`;
+      }
+      if (item.field === "assignee") {
+        return `Assignee: ${escapeSlackMrkdwn(item.fromString || "Unassigned")} \u2192 ${escapeSlackMrkdwn(item.toString || "Unassigned")}`;
+      }
+      if (item.field === "priority") {
+        return `Priority: ${from} \u2192 ${to}`;
+      }
+      return `${escapeSlackMrkdwn(item.field)}: ${from} \u2192 ${to}`;
+    });
+    if (changes.length > 0) {
+      changelogText = "\n" + changes.map((c) => `\u2022 ${c}`).join("\n");
+      if (changelog.items.length > 3) {
+        changelogText += `
+_...and ${changelog.items.length - 3} more changes_`;
+      }
+    }
+  }
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${emoji} Issue ${action}: ${escapeSlackMrkdwn(issue.key)}`,
+        emoji: true
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*<${issueUrl}|${escapeSlackMrkdwn(issue.key)}>* ${escapeSlackMrkdwn(fields.summary)}`
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `${priorityEmoji} *Priority:* ${escapeSlackMrkdwn(fields.priority?.name || "None")}`,
+          `*Status:* ${escapeSlackMrkdwn(fields.status.name)}`,
+          `*Type:* ${escapeSlackMrkdwn(fields.issuetype.name)}`,
+          `*Assignee:* ${escapeSlackMrkdwn(fields.assignee?.displayName || "Unassigned")}`
+        ].join("  |  ")
+      }
+    }
+  ];
+  if (changelogText) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Changes:*${changelogText}`
+      }
+    });
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: `${escapeSlackMrkdwn(user?.displayName || "Someone")} \u2022 ${escapeSlackMrkdwn(fields.project.name)} (${escapeSlackMrkdwn(fields.project.key)})`
+      }
+    ]
+  });
+  blocks.push({
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: {
+          type: "plain_text",
+          text: "View in Jira",
+          emoji: true
+        },
+        url: issueUrl,
+        style: "primary"
+      }
+    ]
+  });
+  return {
+    blocks,
+    text: `${emoji} ${escapeSlackMrkdwn(issue.key)} ${action}: ${escapeSlackMrkdwn(fields.summary)}`
+  };
+}
+function formatCommentEventForSlack(event, siteUrl) {
+  const { issue, comment, webhookEvent } = event;
+  const issueUrl = `${siteUrl}/browse/${issue.key}`;
+  let action;
+  let emoji;
+  switch (webhookEvent) {
+    case "comment_created":
+      action = "commented on";
+      emoji = ":speech_balloon:";
+      break;
+    case "comment_updated":
+      action = "updated comment on";
+      emoji = ":pencil:";
+      break;
+    case "comment_deleted":
+      action = "deleted comment on";
+      emoji = ":x:";
+      break;
+    default:
+      action = "commented on";
+      emoji = ":speech_balloon:";
+  }
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${emoji} ${escapeSlackMrkdwn(comment.author.displayName)} ${action} ${escapeSlackMrkdwn(issue.key)}`,
+        emoji: true
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*<${issueUrl}|${escapeSlackMrkdwn(issue.key)}>* ${escapeSlackMrkdwn(issue.fields.summary)}`
+      }
+    }
+  ];
+  if (webhookEvent !== "comment_deleted") {
+    const bodyText = extractAdfText(comment.body);
+    if (bodyText) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `> ${escapeSlackMrkdwn(bodyText).replace(/\n/g, "\n> ")}`
+        }
+      });
+    }
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: `${escapeSlackMrkdwn(issue.fields.project.name)} \u2022 ${escapeSlackMrkdwn(issue.fields.issuetype.name)}`
+      }
+    ]
+  }, {
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: {
+          type: "plain_text",
+          text: "View in Jira",
+          emoji: true
+        },
+        url: issueUrl,
+        style: "primary"
+      }
+    ]
+  });
+  return {
+    blocks,
+    text: `${emoji} ${escapeSlackMrkdwn(comment.author.displayName)} ${action} ${escapeSlackMrkdwn(issue.key)}: ${escapeSlackMrkdwn(issue.fields.summary)}`
+  };
+}
+function formatSprintEventForSlack(event, siteUrl) {
+  const { sprint, webhookEvent, user } = event;
+  let action;
+  let emoji;
+  switch (webhookEvent) {
+    case "sprint_created":
+      action = "created";
+      emoji = ":calendar:";
+      break;
+    case "sprint_started":
+      action = "started";
+      emoji = ":rocket:";
+      break;
+    case "sprint_closed":
+      action = "completed";
+      emoji = ":checkered_flag:";
+      break;
+    case "sprint_updated":
+      action = "updated";
+      emoji = ":pencil2:";
+      break;
+    case "sprint_deleted":
+      action = "deleted";
+      emoji = ":wastebasket:";
+      break;
+    default:
+      action = "changed";
+      emoji = ":bell:";
+  }
+  const sprintUrl = `${siteUrl}/secure/RapidBoard.jspa?rapidView=${sprint.originBoardId}`;
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${emoji} Sprint ${action}: ${escapeSlackMrkdwn(sprint.name)}`,
+        emoji: true
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `*State:* ${escapeSlackMrkdwn(sprint.state)}`,
+          sprint.startDate ? `*Start:* ${new Date(sprint.startDate).toLocaleDateString()}` : "",
+          sprint.endDate ? `*End:* ${new Date(sprint.endDate).toLocaleDateString()}` : ""
+        ].filter(Boolean).join("  |  ")
+      }
+    }
+  ];
+  if (sprint.goal) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Goal:* ${escapeSlackMrkdwn(sprint.goal)}`
+      }
+    });
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: user?.displayName ? escapeSlackMrkdwn(user.displayName) : "System"
+      }
+    ]
+  });
+  blocks.push({
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: {
+          type: "plain_text",
+          text: "View Board",
+          emoji: true
+        },
+        url: sprintUrl,
+        style: "primary"
+      }
+    ]
+  });
+  return {
+    blocks,
+    text: `${emoji} Sprint ${action}: ${escapeSlackMrkdwn(sprint.name)}`
+  };
+}
+function formatGenericEventForSlack(eventType, payload, siteUrl) {
+  const issue = payload.issue;
+  const user = payload.user;
+  const issueLink = payload.issueLink;
+  const changelog = payload.changelog;
+  const project = payload.project ?? issue?.fields?.project;
+  const version = payload.version;
+  const worklog = payload.worklog;
+  const board = payload.board;
+  const readableEvent = eventType.replace(/^jira:/, "").replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `:bell: ${readableEvent}`,
+        emoji: true
+      }
+    }
+  ];
+  const details = [];
+  if (issue?.key) {
+    const issueUrl = `${siteUrl}/browse/${issue.key}`;
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*<${issueUrl}|${escapeSlackMrkdwn(issue.key)}>* ${escapeSlackMrkdwn(issue.fields?.summary || "")}`
+      }
+    });
+    const meta = [];
+    if (issue.fields?.status?.name)
+      meta.push(`*Status:* ${escapeSlackMrkdwn(issue.fields.status.name)}`);
+    if (issue.fields?.issuetype?.name)
+      meta.push(`*Type:* ${escapeSlackMrkdwn(issue.fields.issuetype.name)}`);
+    if (issue.fields?.priority?.name) {
+      const emoji = getPriorityEmoji(issue.fields.priority.name);
+      meta.push(`${emoji} *Priority:* ${escapeSlackMrkdwn(issue.fields.priority.name)}`);
+    }
+    if (issue.fields?.assignee?.displayName)
+      meta.push(`*Assignee:* ${escapeSlackMrkdwn(issue.fields.assignee.displayName)}`);
+    if (meta.length > 0)
+      details.push(meta.join("  |  "));
+  }
+  if (issueLink?.issueLinkType) {
+    const linkType = issueLink.issueLinkType;
+    const linkDesc = escapeSlackMrkdwn(linkType.outwardName || linkType.name || "linked");
+    details.push(`*Link type:* ${linkDesc}`);
+    if (issueLink.sourceIssueId)
+      details.push(`*Source issue ID:* ${issueLink.sourceIssueId}`);
+    if (issueLink.destinationIssueId)
+      details.push(`*Destination issue ID:* ${issueLink.destinationIssueId}`);
+  }
+  if (version?.name) {
+    const versionParts = [`*Version:* ${escapeSlackMrkdwn(version.name)}`];
+    if (version.description)
+      versionParts.push(escapeSlackMrkdwn(version.description));
+    if (version.released !== void 0)
+      versionParts.push(version.released ? ":white_check_mark: Released" : "Unreleased");
+    details.push(versionParts.join("  |  "));
+  }
+  if (worklog) {
+    const wlParts = [];
+    if (worklog.author?.displayName)
+      wlParts.push(`*By:* ${escapeSlackMrkdwn(worklog.author.displayName)}`);
+    if (worklog.timeSpent)
+      wlParts.push(`*Time:* ${escapeSlackMrkdwn(worklog.timeSpent)}`);
+    if (wlParts.length > 0)
+      details.push(wlParts.join("  |  "));
+  }
+  if (board?.name) {
+    details.push(`*Board:* ${escapeSlackMrkdwn(board.name)}`);
+  }
+  if (changelog?.items && changelog.items.length > 0) {
+    const changes = changelog.items.slice(0, 3).map((item) => `\u2022 ${escapeSlackMrkdwn(item.field || "")}: ${escapeSlackMrkdwn(item.fromString || "None")} \u2192 ${escapeSlackMrkdwn(item.toString || "None")}`);
+    if (changelog.items.length > 3) {
+      changes.push(`_...and ${changelog.items.length - 3} more_`);
+    }
+    details.push(`*Changes:*
+${changes.join("\n")}`);
+  }
+  if (details.length > 0) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: details.join("\n")
+      }
+    });
+  }
+  const contextParts = [];
+  if (user?.displayName)
+    contextParts.push(escapeSlackMrkdwn(user.displayName));
+  if (project?.name)
+    contextParts.push(`${escapeSlackMrkdwn(project.name)}${project.key ? ` (${escapeSlackMrkdwn(project.key)})` : ""}`);
+  if (contextParts.length > 0) {
+    blocks.push({
+      type: "context",
+      elements: [{ type: "mrkdwn", text: contextParts.join(" \u2022 ") }]
+    });
+  }
+  if (issue?.key) {
+    const issueUrl = `${siteUrl}/browse/${issue.key}`;
+    blocks.push({
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          text: { type: "plain_text", text: "View in Jira", emoji: true },
+          url: issueUrl,
+          style: "primary"
+        }
+      ]
+    });
+  }
+  const summary = issue?.key ? `${escapeSlackMrkdwn(issue.key)}: ${escapeSlackMrkdwn(issue.fields?.summary || readableEvent)}` : readableEvent;
+  return {
+    blocks,
+    text: `:bell: ${summary}`
+  };
+}
+
+// ../../b4m-core/packages/common/dist/src/jira/webhook/api.js
+var WebhookApi = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build URL for webhook API endpoints.
+   *
+   * Note: Webhooks use a different base URL than other Jira APIs.
+   */
+  buildUrl(path, query = {}) {
+    const url = new URL(`${this.config.apiBaseUrl}${path}`);
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.append(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Make an authenticated request to the Jira Webhook API.
+   */
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const headers = {
+      Authorization: this.config.authHeader,
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Jira Webhook API error (${response.status}): ${errorBody}`);
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    const data = await response.json();
+    return data;
+  }
+  // ============================================================================
+  // Webhook CRUD Operations
+  // ============================================================================
+  /**
+   * List all webhooks registered by this OAuth app.
+   *
+   * @param startAt - Pagination start index (default: 0)
+   * @param maxResults - Max results per page (default: 50, max: 100)
+   */
+  async listWebhooks(params = {}) {
+    const { startAt = 0, maxResults = 50 } = params;
+    const response = await this.request("GET", "/webhook", {
+      query: { startAt, maxResults }
+    });
+    return formatWebhookList(response);
+  }
+  /**
+   * Register a new webhook.
+   *
+   * @param url - The URL where Jira will POST webhook events
+   * @param events - Events to subscribe to
+   * @param jqlFilter - Optional JQL filter (only matching issues trigger events)
+   * @returns The created webhook ID
+   */
+  async registerWebhook(params) {
+    const { url, events, jqlFilter } = params;
+    const webhook = {
+      // Jira webhook API requires jqlFilter but has limited operator support.
+      // "IS NOT EMPTY" and empty strings are rejected. Use a universally-true expression.
+      jqlFilter: jqlFilter || "project != null",
+      events
+    };
+    const body = {
+      url,
+      webhooks: [webhook]
+    };
+    const response = await this.request("POST", "/webhook", {
+      body
+    });
+    console.log("[JIRA-WEBHOOK-API] registerWebhook raw response:", JSON.stringify(response, null, 2));
+    if (!response.webhookRegistrationResult || response.webhookRegistrationResult.length === 0) {
+      throw new Error("Failed to register webhook: No registration result returned");
+    }
+    const result = response.webhookRegistrationResult[0];
+    if (result.errors && result.errors.length > 0) {
+      throw new Error(`Failed to register webhook: ${result.errors.join(", ")}`);
+    }
+    if (result.createdWebhookId === void 0 || result.createdWebhookId === null) {
+      throw new Error(`Failed to register webhook: No webhook ID in response. Full result: ${JSON.stringify(result)}`);
+    }
+    return {
+      webhookId: result.createdWebhookId
+    };
+  }
+  /**
+   * Refresh webhook expiration dates.
+   *
+   * Jira webhooks expire after 30 days. Call this to extend expiration.
+   *
+   * @param webhookIds - IDs of webhooks to refresh
+   * @returns New expiration date
+   */
+  async refreshWebhooks(params) {
+    const { webhookIds } = params;
+    const body = {
+      webhookIds
+    };
+    const response = await this.request("PUT", "/webhook/refresh", {
+      body
+    });
+    return {
+      expirationDate: response.expirationDate
+    };
+  }
+  /**
+   * Delete webhooks by ID.
+   *
+   * @param webhookIds - IDs of webhooks to delete
+   */
+  async deleteWebhooks(params) {
+    const { webhookIds } = params;
+    const body = {
+      webhookIds
+    };
+    await this.request("DELETE", "/webhook", {
+      body
+    });
+  }
+  /**
+   * Get a specific webhook by ID.
+   *
+   * Note: Jira API doesn't have a direct "get by ID" endpoint,
+   * so we list and filter.
+   */
+  async getWebhook(params) {
+    const { webhookId } = params;
+    const response = await this.request("GET", "/webhook", {
+      query: { startAt: 0, maxResults: 100 }
+    });
+    const webhook = response.values.find((w) => w.id === webhookId);
+    return webhook || null;
+  }
+};
+
 // ../../b4m-core/packages/common/dist/src/jira/api.js
 var JIRA_MAX_ATTACHMENT_SIZE = 20 * 1024 * 1024;
 function isValidIssueKey(key) {
@@ -8009,8 +8666,71 @@ var JiraApi = class {
     }
     return this._agileApi;
   }
+  // ============================================================================
+  // Webhook API Access (Webhook Management)
+  // ============================================================================
+  _webhookApi = null;
+  /**
+   * Get the Webhook API client for webhook management operations.
+   * Lazily instantiated on first access.
+   */
+  get webhook() {
+    if (!this._webhookApi) {
+      this._webhookApi = new WebhookApi(this.config);
+    }
+    return this._webhookApi;
+  }
 };
 
+// ../../b4m-core/packages/common/dist/src/jira/webhook/types.js
+function isIssueWebhookEvent(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || !event.startsWith("jira:issue_"))
+    return false;
+  const issue = payload.issue;
+  if (!issue || typeof issue.key !== "string")
+    return false;
+  const fields = issue.fields;
+  if (!fields || typeof fields.summary !== "string")
+    return false;
+  const status = fields.status;
+  const issuetype = fields.issuetype;
+  const project = fields.project;
+  if (!status?.name || !issuetype?.name || !project?.key)
+    return false;
+  return true;
+}
+function isCommentWebhookEvent(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || !event.startsWith("comment_"))
+    return false;
+  const issue = payload.issue;
+  if (!issue || typeof issue.key !== "string")
+    return false;
+  const comment = payload.comment;
+  if (!comment || typeof comment.id !== "string")
+    return false;
+  const author = comment.author;
+  if (!author || typeof author.displayName !== "string")
+    return false;
+  return true;
+}
+function isSprintWebhookEvent(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || !event.startsWith("sprint_"))
+    return false;
+  const sprint = payload.sprint;
+  if (!sprint || typeof sprint.name !== "string")
+    return false;
+  return true;
+}
+function extractWebhookEventType(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || event.length === 0)
+    return null;
+  return event;
+}
+
 // ../../b4m-core/packages/common/dist/src/atlassian/config.js
 function getErrorMessage(error) {
   if (error instanceof Error) {
@@ -8597,6 +9317,7 @@ export {
   ChatModels,
   CHAT_MODELS,
   supportedChatModels,
+  REASONING_SUPPORTED_MODELS,
   SpeechToTextModels,
   SPEECH_TO_TEXT_MODELS,
   supportedSpeechToTextModels,
@@ -8703,6 +9424,8 @@ export {
   isPlaceholderValue,
   SecretAuditEvents,
   WebhookDeliveryStatus,
+  COMMON_JIRA_WEBHOOK_EVENTS,
+  JiraWebhookDeliveryStatus,
   SupportedFabFileMimeTypes,
   REASONING_EFFORT_LABELS,
   REASONING_EFFORT_DESCRIPTIONS,
@@ -8940,11 +9663,24 @@ export {
   formatIssueLinkTypes,
   formatIssueLinks,
   AgileApi,
+  formatWebhook,
+  formatWebhookList,
+  extractAdfText,
+  escapeSlackMrkdwn,
+  formatIssueEventForSlack,
+  formatCommentEventForSlack,
+  formatSprintEventForSlack,
+  formatGenericEventForSlack,
+  WebhookApi,
   JIRA_MAX_ATTACHMENT_SIZE,
   isValidIssueKey,
   wikiMarkupToAdf,
   containsWikiTable,
   JiraApi,
+  isIssueWebhookEvent,
+  isCommentWebhookEvent,
+  isSprintWebhookEvent,
+  extractWebhookEventType,
   getErrorMessage,
   getAtlassianConfig,
   MCP_PROVIDER_METADATA,