@integrity-labs/agt-cli 0.15.10 → 0.15.11

package/mcp/slack-channel.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -6798,6 +6801,402 @@ var require_dist = __commonJS({
   }
 });
 
+// src/slack-block-kit-runtime.ts
+var slack_block_kit_runtime_exports = {};
+__export(slack_block_kit_runtime_exports, {
+  buildAskUserBlocks: () => buildAskUserBlocks,
+  buildRatingActionsBlock: () => buildRatingActionsBlock,
+  createPendingInteraction: () => createPendingInteraction,
+  decodeActionId: () => decodeActionId,
+  defaultRatingLabels: () => defaultRatingLabels,
+  encodeActionId: () => encodeActionId,
+  generateOptionToken: () => generateOptionToken,
+  ratingValuesForScale: () => ratingValuesForScale,
+  recordSlackDelivery: () => recordSlackDelivery,
+  resolveInteractive: () => resolveInteractive,
+  updatePendingInteractionMessageTs: () => updatePendingInteractionMessageTs,
+  validateAskUserOptions: () => validateAskUserOptions,
+  validateSlackBlocks: () => validateSlackBlocks,
+  waitForResolution: () => waitForResolution
+});
+async function getAuthToken(cfg) {
+  if (auth.token && Date.now() < auth.expiresAtEpochMs) return auth.token;
+  const res = await fetch(`${cfg.apiHost}/host/exchange`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ host_key: cfg.apiKey }),
+    signal: AbortSignal.timeout(API_FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`AGT auth exchange failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+  const data = await res.json();
+  auth.token = data.token;
+  auth.expiresAtEpochMs = data.expires_at ? new Date(data.expires_at).getTime() - 12e4 : Date.now() + 55 * 6e4;
+  return auth.token;
+}
+async function apiCall(cfg, method, path, body) {
+  const token = await getAuthToken(cfg);
+  const buildInit = (authToken) => ({
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authToken}`
+    },
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+    signal: AbortSignal.timeout(API_FETCH_TIMEOUT_MS)
+  });
+  const res = await fetch(`${cfg.apiHost}${path}`, buildInit(token));
+  if (res.status !== 401) return res;
+  auth.token = null;
+  auth.expiresAtEpochMs = 0;
+  const fresh = await getAuthToken(cfg);
+  return fetch(`${cfg.apiHost}${path}`, buildInit(fresh));
+}
+async function createPendingInteraction(cfg, input) {
+  const res = await apiCall(cfg, "POST", "/host/pending-interactions", {
+    agent_id: cfg.agentId,
+    callback_id: input.callbackId,
+    channel_id: input.channelId,
+    message_ts: input.messageTs ?? "",
+    thread_ts: input.threadTs,
+    options: input.options,
+    expires_at: input.expiresAt.toISOString(),
+    kind: input.kind,
+    kind_data: input.kindData
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`createPendingInteraction failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+}
+async function updatePendingInteractionMessageTs(cfg, callbackId, messageTs) {
+  const res = await apiCall(cfg, "PATCH", `/host/pending-interactions/${encodeURIComponent(callbackId)}`, {
+    agent_id: cfg.agentId,
+    message_ts: messageTs
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`updatePendingInteractionMessageTs failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+}
+async function waitForResolution(cfg, callbackId, opts) {
+  const interval = opts.pollIntervalMs ?? 500;
+  const deadlineMs = opts.deadline.getTime();
+  let firstPass = true;
+  while (firstPass || Date.now() < deadlineMs) {
+    firstPass = false;
+    try {
+      const res = await apiCall(
+        cfg,
+        "GET",
+        `/host/pending-interactions/${encodeURIComponent(callbackId)}?agent_id=${encodeURIComponent(cfg.agentId)}`
+      );
+      if (res.ok) {
+        const row = await res.json();
+        if (row.status === "resolved") {
+          return {
+            kind: "resolved",
+            value: row.value ?? "",
+            respondedByUser: row.responded_by_user,
+            respondedAt: row.responded_at ?? (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        if (row.status === "timeout") {
+          return { kind: "timeout" };
+        }
+      }
+    } catch {
+    }
+    await sleep(interval);
+  }
+  return { kind: "timeout" };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function generateOptionToken() {
+  const bytes = new Uint8Array(12);
+  const webCrypto = globalThis.crypto;
+  if (webCrypto && typeof webCrypto.getRandomValues === "function") {
+    webCrypto.getRandomValues(bytes);
+  } else {
+    throw new Error(
+      "generateOptionToken: no crypto.getRandomValues implementation available. Need Node 20+ or a Web Crypto polyfill."
+    );
+  }
+  const out = Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return out;
+}
+function validateSlackBlocks(blocks) {
+  const errors = [];
+  const cap = 10;
+  const push = (path, message) => {
+    if (errors.length < cap) errors.push({ path, message });
+  };
+  if (!Array.isArray(blocks)) {
+    return { ok: false, errors: [{ path: "blocks", message: "must be an array" }] };
+  }
+  if (blocks.length === 0) {
+    return { ok: false, errors: [{ path: "blocks", message: "must contain at least one block" }] };
+  }
+  if (blocks.length > SLACK_LIMITS.blocksPerMessage) {
+    push("blocks", `max ${SLACK_LIMITS.blocksPerMessage} blocks per message (got ${blocks.length})`);
+  }
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const path = `blocks[${i}]`;
+    const type = block?.type;
+    if (typeof type !== "string") {
+      push(path, "block.type is required");
+      continue;
+    }
+    if (!SUPPORTED_BLOCK_TYPES.includes(type)) {
+      push(path, `block type '${type}' is not supported. Use one of: ${SUPPORTED_BLOCK_TYPES.join(", ")}`);
+      continue;
+    }
+    if (typeof block.block_id === "string" && block.block_id.length > SLACK_LIMITS.identifierChars) {
+      push(`${path}.block_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
+    }
+    switch (type) {
+      case "header":
+        validateHeaderBlock(block, path, push);
+        break;
+      case "section":
+        validateSectionBlock(block, path, push);
+        break;
+      case "context":
+        validateContextBlock(block, path, push);
+        break;
+      case "actions":
+        validateActionsBlock(block, path, push);
+        break;
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+function validateHeaderBlock(b, path, push) {
+  const text = b.text;
+  if (!text || text.type !== "plain_text" || typeof text.text !== "string") {
+    push(`${path}.text`, "header.text must be { type: 'plain_text', text: string }");
+    return;
+  }
+  if (text.text.length > SLACK_LIMITS.headerTextChars) {
+    push(`${path}.text.text`, `max ${SLACK_LIMITS.headerTextChars} chars`);
+  }
+}
+function validateSectionBlock(b, path, push) {
+  const hasText = "text" in b;
+  const hasFields = "fields" in b;
+  if (!hasText && !hasFields) {
+    push(path, "section block requires text or fields");
+    return;
+  }
+  if (hasText) validateTextObject(b.text, `${path}.text`, push, SLACK_LIMITS.sectionTextChars);
+  if (hasFields) {
+    if (!Array.isArray(b.fields)) {
+      push(`${path}.fields`, "must be an array");
+      return;
+    }
+    if (b.fields.length > SLACK_LIMITS.sectionFields) {
+      push(`${path}.fields`, `max ${SLACK_LIMITS.sectionFields} fields (got ${b.fields.length})`);
+    }
+    b.fields.forEach(
+      (f, i) => validateTextObject(f, `${path}.fields[${i}]`, push, SLACK_LIMITS.sectionFieldChars)
+    );
+  }
+}
+function validateContextBlock(b, path, push) {
+  if (!Array.isArray(b.elements) || b.elements.length === 0) {
+    push(`${path}.elements`, "context block requires non-empty elements array");
+    return;
+  }
+  b.elements.forEach(
+    (el, i) => validateTextObject(el, `${path}.elements[${i}]`, push, SLACK_LIMITS.sectionFieldChars)
+  );
+}
+function validateActionsBlock(b, path, push) {
+  if (!Array.isArray(b.elements) || b.elements.length === 0) {
+    push(`${path}.elements`, "actions block requires non-empty elements array");
+    return;
+  }
+  if (b.elements.length > SLACK_LIMITS.actionElements) {
+    push(`${path}.elements`, `max ${SLACK_LIMITS.actionElements} action elements (got ${b.elements.length})`);
+  }
+  b.elements.forEach((el, i) => {
+    const elPath = `${path}.elements[${i}]`;
+    const e = el;
+    if (typeof e?.type !== "string") {
+      push(elPath, "element.type is required");
+      return;
+    }
+    if (!SUPPORTED_ACTION_ELEMENTS.includes(e.type)) {
+      push(elPath, `element type '${e.type}' is not supported. Use one of: ${SUPPORTED_ACTION_ELEMENTS.join(", ")}`);
+      return;
+    }
+    if (typeof e.action_id !== "string" || e.action_id.length === 0) {
+      push(`${elPath}.action_id`, "required");
+    } else if (e.action_id.length > SLACK_LIMITS.identifierChars) {
+      push(`${elPath}.action_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
+    }
+    if (e.type === "button") {
+      const t = e.text;
+      if (!t || t.type !== "plain_text" || typeof t.text !== "string") {
+        push(`${elPath}.text`, "button.text must be { type: 'plain_text', text: string }");
+      } else if (t.text.length > SLACK_LIMITS.buttonLabelChars) {
+        push(`${elPath}.text.text`, `max ${SLACK_LIMITS.buttonLabelChars} chars`);
+      }
+    }
+  });
+}
+function validateTextObject(obj, path, push, maxChars) {
+  if (!obj || typeof obj !== "object") {
+    push(path, "must be a text object");
+    return;
+  }
+  if (obj.type !== "plain_text" && obj.type !== "mrkdwn") {
+    push(`${path}.type`, "must be 'plain_text' or 'mrkdwn'");
+    return;
+  }
+  if (typeof obj.text !== "string") {
+    push(`${path}.text`, "must be a string");
+    return;
+  }
+  if (obj.text.length > maxChars) {
+    push(`${path}.text`, `max ${maxChars} chars (got ${obj.text.length})`);
+  }
+}
+function validateAskUserOptions(options) {
+  const errors = [];
+  if (!Array.isArray(options)) {
+    return { ok: false, errors: [{ path: "options", message: "must be an array" }] };
+  }
+  if (options.length === 0) {
+    errors.push({ path: "options", message: "must contain at least one option" });
+  }
+  if (options.length > SLACK_LIMITS.actionElements) {
+    errors.push({ path: "options", message: `max ${SLACK_LIMITS.actionElements} options (one Slack actions block)` });
+  }
+  const seenLabels = /* @__PURE__ */ new Set();
+  const seenValues = /* @__PURE__ */ new Set();
+  options.forEach((opt, i) => {
+    const o = opt;
+    const path = `options[${i}]`;
+    if (typeof o?.label !== "string" || o.label.length === 0) {
+      errors.push({ path: `${path}.label`, message: "required string" });
+    } else {
+      if (o.label.length > SLACK_LIMITS.buttonLabelChars) {
+        errors.push({ path: `${path}.label`, message: `max ${SLACK_LIMITS.buttonLabelChars} chars` });
+      }
+      if (seenLabels.has(o.label)) errors.push({ path: `${path}.label`, message: "duplicate label" });
+      seenLabels.add(o.label);
+    }
+    if (typeof o?.value !== "string" || o.value.length === 0) {
+      errors.push({ path: `${path}.value`, message: "required string" });
+    } else {
+      if (o.value.length > SLACK_LIMITS.optionValueChars) {
+        errors.push({ path: `${path}.value`, message: `max ${SLACK_LIMITS.optionValueChars} chars` });
+      }
+      if (seenValues.has(o.value)) errors.push({ path: `${path}.value`, message: "duplicate value" });
+      seenValues.add(o.value);
+    }
+  });
+  return { ok: errors.length === 0, errors };
+}
+function encodeActionId(callbackId, token) {
+  return `aug:${callbackId}:${token}`;
+}
+function decodeActionId(actionId) {
+  const m = ACTION_ID_RE.exec(actionId);
+  if (!m) return null;
+  return { callbackId: m[1], token: m[2] };
+}
+function buildAskUserBlocks(opts) {
+  return [
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: opts.question }
+    },
+    {
+      type: "actions",
+      elements: opts.options.map(({ label, token }) => ({
+        type: "button",
+        text: { type: "plain_text", text: label },
+        action_id: encodeActionId(opts.callbackId, token)
+      }))
+    }
+  ];
+}
+function ratingValuesForScale(scale) {
+  return scale === "1-5" ? [1, 2, 3, 4, 5] : [-1, 0, 1];
+}
+function defaultRatingLabels(scale) {
+  return scale === "1-5" ? ["1", "2", "3", "4", "5"] : ["\u{1F44E}", "\u{1F914}", "\u{1F44D}"];
+}
+function buildRatingActionsBlock(opts) {
+  return {
+    type: "actions",
+    elements: opts.options.map(({ label, token }) => ({
+      type: "button",
+      text: { type: "plain_text", text: label },
+      action_id: encodeActionId(opts.callbackId, token)
+    }))
+  };
+}
+async function resolveInteractive(cfg, input) {
+  const res = await apiCall(cfg, "POST", "/host/interactive/resolve", {
+    agent_id: cfg.agentId,
+    callback_id: input.callbackId,
+    token: input.token,
+    responded_by_user: input.respondedByUser,
+    response_url: input.responseUrl,
+    original_blocks: input.originalBlocks
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`resolveInteractive failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+}
+async function recordSlackDelivery(cfg, input) {
+  const res = await apiCall(
+    cfg,
+    "POST",
+    `/host/agents/${encodeURIComponent(cfg.agentId)}/slack-delivery`,
+    {
+      channel: input.channel,
+      message_ts: input.messageTs,
+      thread_ts: input.threadTs
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`recordSlackDelivery failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+}
+var auth, API_FETCH_TIMEOUT_MS, SLACK_LIMITS, SUPPORTED_BLOCK_TYPES, SUPPORTED_ACTION_ELEMENTS, ACTION_ID_RE;
+var init_slack_block_kit_runtime = __esm({
+  "src/slack-block-kit-runtime.ts"() {
+    "use strict";
+    auth = { token: null, expiresAtEpochMs: 0 };
+    API_FETCH_TIMEOUT_MS = 1e4;
+    SLACK_LIMITS = {
+      blocksPerMessage: 50,
+      sectionTextChars: 3e3,
+      sectionFields: 10,
+      sectionFieldChars: 2e3,
+      actionElements: 5,
+      buttonLabelChars: 75,
+      identifierChars: 255,
+      optionValueChars: 2e3,
+      headerTextChars: 150
+    };
+    SUPPORTED_BLOCK_TYPES = ["header", "section", "divider", "context", "actions"];
+    SUPPORTED_ACTION_ELEMENTS = ["button"];
+    ACTION_ID_RE = /^aug:([0-9a-f-]{36}):([A-Za-z0-9_-]{1,200})$/;
+  }
+});
+
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
   status: "aborted"
@@ -14164,6 +14563,12 @@ function channelMessageShouldRespond(text, mode) {
 var BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
 var APP_TOKEN = process.env.SLACK_APP_TOKEN;
 var AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME ?? null;
+var AGT_HOST = process.env.AGT_HOST ?? null;
+var AGT_API_KEY = process.env.AGT_API_KEY ?? null;
+var AGT_AGENT_ID = process.env.AGT_AGENT_ID ?? null;
+var BLOCK_KIT_ENABLED = process.env.SLACK_BLOCK_KIT_ENABLED === "true";
+var BLOCK_KIT_ASK_USER_ENABLED = process.env.SLACK_BLOCK_KIT_ASK_USER_ENABLED === "true";
+var BLOCK_KIT_DISABLED = process.env.SLACK_BLOCK_KIT_DISABLED === "true";
 var ALLOWED_USERS = new Set(
   (process.env.SLACK_ALLOWED_USERS ?? "").split(",").map((s) => s.trim()).filter(Boolean)
 );
@@ -14448,6 +14853,9 @@ var RESTART_FLAGS_DIR = join2(homedir2(), ".augmented", "restart-flags");
 function hashChannelId(id) {
   return createHash("sha256").update(id).digest("hex").slice(0, 8);
 }
+function hashId(id) {
+  return createHash("sha256").update(id).digest("hex").slice(0, 8);
+}
 async function postSlackMessage(body) {
   try {
     const res = await fetch("https://slack.com/api/chat.postMessage", {
@@ -14710,6 +15118,63 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["file_id", "channel"]
       }
     },
+    // ENG-4573: Block Kit tools — only listed when the team has opted in
+    // and the env wiring is present. The kill-switch (SLACK_BLOCK_KIT_DISABLED)
+    // takes precedence so an operator can pull the tools at runtime
+    // without redeploying.
+    ...blockKitToolsAvailable() ? [
+      {
+        name: "slack.send_structured",
+        description: 'Send a Slack message built from Block Kit blocks (structured layout: headers, sections, dividers, context, action buttons). Use when plain text isn\'t enough \u2014 status reports, confirmations with multiple fields, calls-to-action with buttons. Pass a `text` fallback for push notifications. Returns { message_ts, permalink }. Does NOT block waiting for user interactions; for that use slack.ask_user. Pass `interactive: { type: "rate_run", run_id }` to append a 1-5 rating button row that records the score against this scheduled-task run (ENG-4572).',
+        inputSchema: {
+          type: "object",
+          properties: {
+            channel: { type: "string", description: "Slack channel ID" },
+            blocks: {
+              type: "array",
+              description: "Array of Block Kit blocks. Supported block types: header, section, divider, context, actions. Supported interactive elements (inside actions blocks): button. Hard limits: 50 blocks per message, 5 elements per actions block, 3000 chars per section text, 75 chars per button label."
+            },
+            text: { type: "string", description: "Plain-text fallback for push notifications and unfurls. Required." },
+            thread_ts: { type: "string", description: "Thread timestamp for threaded replies (optional)" },
+            interactive: {
+              type: "object",
+              description: `Optional interactive affordance appended to the message. Currently supports type="rate_run" \u2014 appends a 1-5 button row that updates this run's rating when tapped. Use after a scheduled-task delivery so users can rate the firing.`,
+              properties: {
+                type: { type: "string", enum: ["rate_run"], description: 'Affordance kind. Only "rate_run" is supported today.' },
+                run_id: { type: "string", description: "The runs.run_id this rating belongs to (returned by /host/runs/start)." },
+                scale: { type: "string", enum: ["1-5", "sentiment"], description: 'Rating scale. Default "1-5" (1..5 buttons). "sentiment" emits \u{1F44E}/\u{1F914}/\u{1F44D} mapping to -1/0/+1 \u2014 reserved for future Telegram parity.' },
+                expires_in_seconds: { type: "number", description: "How long the rating row stays tappable. Default 86400 (24h). The pending row times out after this; later taps are ignored." }
+              },
+              required: ["type", "run_id"]
+            }
+          },
+          required: ["channel", "blocks", "text"]
+        }
+      }
+    ] : [],
+    ...askUserToolAvailable() ? [
+      {
+        name: "slack.ask_user",
+        description: "Post a question to Slack with multiple-choice buttons and BLOCK until the user taps one (or the timeout fires). Returns the user's choice as { value, label, responded_by, timed_out, responded_at }. Use sparingly \u2014 this stops the agent for up to 5 minutes by default. Prefer plain slack.reply for asking questions where you don't need a structured answer back.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            channel: { type: "string", description: "Slack channel ID" },
+            question: { type: "string", description: "The prompt shown above the buttons. Markdown is supported." },
+            options: {
+              type: "array",
+              description: "Up to 5 options. Each is { label: string (button text, max 75 chars), value: string (returned to you on tap, max 2000 chars) }. Labels and values must be unique within the array."
+            },
+            timeout_seconds: {
+              type: "number",
+              description: "How long to wait for a response. Min 10, max 3600, default 300 (5 min)."
+            },
+            thread_ts: { type: "string", description: "Optional \u2014 post into a specific thread." }
+          },
+          required: ["channel", "question", "options"]
+        }
+      }
+    ] : [],
     {
       name: "slack.upload_file",
       description: "Upload a file from the agent project dir to a Slack channel or thread. Use this for PDFs, images, reports, and any binary deliverables the agent generates. Path must be inside the agent's project directory.",
@@ -14777,6 +15242,30 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         const trackTs = thread_ts ?? data.ts ?? void 0;
         rememberThread(channel, trackTs, thread_ts ? "mentioned" : "started");
       }
+      if (interactiveHostAvailable() && data.ts) {
+        const cfg = {
+          apiHost: AGT_HOST,
+          apiKey: AGT_API_KEY,
+          agentId: AGT_AGENT_ID
+        };
+        const tsToRecord = data.ts;
+        const threadTsToRecord = thread_ts;
+        void (async () => {
+          try {
+            const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
+            await runtime.recordSlackDelivery(cfg, {
+              channel,
+              messageTs: tsToRecord,
+              threadTs: threadTsToRecord
+            });
+          } catch (err) {
+            process.stderr.write(
+              `slack-channel(${AGENT_CODE_NAME}): recordSlackDelivery failed: ${err.message}
+`
+            );
+          }
+        })();
+      }
       return { content: [{ type: "text", text: "sent" }] };
     } catch (err) {
       return {
@@ -15020,8 +15509,303 @@ ${formatted}` : "Thread is empty or not found."
       };
     }
   }
+  if (name === "slack.send_structured") {
+    return await handleSendStructured(args);
+  }
+  if (name === "slack.ask_user") {
+    return await handleAskUser(args);
+  }
   throw new Error(`Unknown tool: ${name}`);
 });
+function blockKitToolsAvailable() {
+  return BLOCK_KIT_ENABLED && !BLOCK_KIT_DISABLED;
+}
+function askUserToolAvailable() {
+  return blockKitToolsAvailable() && BLOCK_KIT_ASK_USER_ENABLED && Boolean(AGT_HOST && AGT_API_KEY && AGT_AGENT_ID);
+}
+function interactiveHostAvailable() {
+  return blockKitToolsAvailable() && Boolean(AGT_HOST && AGT_API_KEY && AGT_AGENT_ID);
+}
+async function postSlackMessageWithTs(payload) {
+  try {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        Authorization: `Bearer ${BOT_TOKEN}`
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(SLACK_DOWNLOAD_TIMEOUT_MS)
+    });
+    return await res.json();
+  } catch (err) {
+    const isTimeout = err.name === "TimeoutError" || err.name === "AbortError";
+    return { ok: false, error: isTimeout ? "timeout" : err.message };
+  }
+}
+async function getPermalink(channel, ts) {
+  try {
+    const url = `https://slack.com/api/chat.getPermalink?channel=${encodeURIComponent(channel)}&message_ts=${encodeURIComponent(ts)}`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${BOT_TOKEN}` },
+      signal: AbortSignal.timeout(SLACK_DOWNLOAD_TIMEOUT_MS)
+    });
+    const data = await res.json();
+    return data.ok && typeof data.permalink === "string" ? data.permalink : null;
+  } catch {
+    return null;
+  }
+}
+async function handleSendStructured(args) {
+  if (!blockKitToolsAvailable()) {
+    return {
+      content: [{ type: "text", text: "slack.send_structured is disabled by team configuration." }],
+      isError: true
+    };
+  }
+  const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
+  const { validateSlackBlocks: validateSlackBlocks2 } = runtime;
+  const { channel, blocks, text, thread_ts, interactive } = args;
+  if (typeof channel !== "string" || !channel) {
+    return errResult("channel is required");
+  }
+  if (typeof text !== "string" || !text) {
+    return errResult("text is required (used as fallback for push notifications and unfurls)");
+  }
+  const validation = validateSlackBlocks2(blocks);
+  if (!validation.ok) {
+    return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+  }
+  let effectiveBlocks = blocks;
+  let ratingCallbackId = null;
+  let ratingExpiresAt = null;
+  let ratingTokenised = [];
+  if (interactive) {
+    if (interactive.type !== "rate_run") {
+      return errResult(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
+    }
+    if (typeof interactive.run_id !== "string" || !interactive.run_id) {
+      return errResult("interactive.run_id is required when interactive is set");
+    }
+    if (!interactiveHostAvailable()) {
+      return errResult(
+        "interactive=rate_run requires Block Kit plus host MCP wiring (AGT_HOST, AGT_API_KEY, AGT_AGENT_ID)."
+      );
+    }
+    const scale = interactive.scale === "sentiment" ? "sentiment" : "1-5";
+    const requestedTtl = typeof interactive.expires_in_seconds === "number" ? interactive.expires_in_seconds : 86400;
+    const ttl = Math.max(60, Math.min(7 * 86400, requestedTtl));
+    const { randomUUID: rndUUID } = await import("crypto");
+    ratingCallbackId = rndUUID();
+    ratingExpiresAt = new Date(Date.now() + ttl * 1e3);
+    const values = runtime.ratingValuesForScale(scale);
+    const labels = runtime.defaultRatingLabels(scale);
+    ratingTokenised = values.map((v, i) => ({
+      token: runtime.generateOptionToken(),
+      value: String(v),
+      label: labels[i] ?? String(v)
+    }));
+    const ratingBlock = runtime.buildRatingActionsBlock({
+      callbackId: ratingCallbackId,
+      options: ratingTokenised.map(({ label, token }) => ({
+        // The numeric value is carried by token → options mapping in the
+        // pending_interaction row, not by the button itself, so this
+        // cast-back to RatingOption only needs label + token + a placeholder.
+        value: 0,
+        label,
+        token
+      }))
+    });
+    effectiveBlocks = [...blocks, ratingBlock];
+    const finalValidation = runtime.validateSlackBlocks(effectiveBlocks);
+    if (!finalValidation.ok) {
+      return errResult(
+        `Invalid blocks (after appending rating row): ${finalValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
+      );
+    }
+    const cfg = {
+      apiHost: AGT_HOST,
+      apiKey: AGT_API_KEY,
+      agentId: AGT_AGENT_ID
+    };
+    try {
+      await runtime.createPendingInteraction(cfg, {
+        callbackId: ratingCallbackId,
+        channelId: channel,
+        messageTs: "",
+        threadTs: thread_ts,
+        options: ratingTokenised,
+        expiresAt: ratingExpiresAt,
+        kind: "rate_run",
+        kindData: { run_id: interactive.run_id, scale }
+      });
+    } catch (err) {
+      return errResult(`Failed to register rating row: ${err.message}`);
+    }
+  }
+  const result = await postSlackMessageWithTs({
+    channel,
+    blocks: effectiveBlocks,
+    text,
+    ...thread_ts ? { thread_ts } : {}
+  });
+  if (!result.ok || !result.ts) {
+    return errResult(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
+  }
+  if (ratingCallbackId) {
+    try {
+      await runtime.updatePendingInteractionMessageTs(
+        { apiHost: AGT_HOST, apiKey: AGT_API_KEY, agentId: AGT_AGENT_ID },
+        ratingCallbackId,
+        result.ts
+      );
+    } catch (err) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): updatePendingInteractionMessageTs failed for rating ${hashId(ratingCallbackId)}: ${err.message}
+`
+      );
+    }
+  }
+  if (interactiveHostAvailable() && !ratingCallbackId) {
+    const cfg = {
+      apiHost: AGT_HOST,
+      apiKey: AGT_API_KEY,
+      agentId: AGT_AGENT_ID
+    };
+    const tsToRecord = result.ts;
+    const threadTsToRecord = thread_ts;
+    void (async () => {
+      try {
+        await runtime.recordSlackDelivery(cfg, {
+          channel,
+          messageTs: tsToRecord,
+          threadTs: threadTsToRecord
+        });
+      } catch (err) {
+        process.stderr.write(
+          `slack-channel(${AGENT_CODE_NAME}): recordSlackDelivery (send_structured) failed: ${err.message}
+`
+        );
+      }
+    })();
+  }
+  const permalink = await getPermalink(channel, result.ts);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          message_ts: result.ts,
+          permalink: permalink ?? "",
+          ...ratingCallbackId ? { rating_callback_id: ratingCallbackId } : {}
+        })
+      }
+    ]
+  };
+}
+async function handleAskUser(args) {
+  if (!askUserToolAvailable()) {
+    return errResult("slack.ask_user is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring.");
+  }
+  const { randomUUID: rndUUID } = await import("crypto");
+  const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
+  const { validateAskUserOptions: validateAskUserOptions2, buildAskUserBlocks: buildAskUserBlocks2 } = runtime;
+  const { channel, question, options, timeout_seconds, thread_ts } = args;
+  if (typeof channel !== "string" || !channel) return errResult("channel is required");
+  if (typeof question !== "string" || !question) return errResult("question is required");
+  const optsValidation = validateAskUserOptions2(options);
+  if (!optsValidation.ok) {
+    return errResult(`Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+  }
+  const requestedTimeout = typeof timeout_seconds === "number" ? timeout_seconds : 300;
+  const timeoutSec = Math.max(10, Math.min(3600, requestedTimeout));
+  const callbackId = rndUUID();
+  const optionsArr = options;
+  const tokenised = optionsArr.map(({ label, value }) => ({
+    token: runtime.generateOptionToken(),
+    label,
+    value
+  }));
+  const blocks = buildAskUserBlocks2({
+    callbackId,
+    question,
+    options: tokenised.map(({ label, token }) => ({ label, token }))
+  });
+  const cfg = {
+    apiHost: AGT_HOST,
+    apiKey: AGT_API_KEY,
+    agentId: AGT_AGENT_ID
+  };
+  const expiresAt = new Date(Date.now() + timeoutSec * 1e3);
+  try {
+    await runtime.createPendingInteraction(cfg, {
+      callbackId,
+      channelId: channel,
+      messageTs: "",
+      // placeholder — patched after Slack returns the real ts
+      threadTs: thread_ts,
+      options: tokenised,
+      expiresAt
+    });
+  } catch (err) {
+    return errResult(`Failed to register pending interaction: ${err.message}`);
+  }
+  const slackResult = await postSlackMessageWithTs({
+    channel,
+    blocks,
+    text: question,
+    // fallback for push notifications
+    ...thread_ts ? { thread_ts } : {}
+  });
+  if (!slackResult.ok || !slackResult.ts) {
+    return errResult(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
+  }
+  try {
+    await runtime.updatePendingInteractionMessageTs(cfg, callbackId, slackResult.ts);
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): updatePendingInteractionMessageTs failed for ${callbackId}: ${err.message}
+`
+    );
+  }
+  const resolution = await runtime.waitForResolution(cfg, callbackId, {
+    deadline: expiresAt
+  });
+  if (resolution.kind === "timeout") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            value: null,
+            label: null,
+            responded_by: null,
+            responded_at: null,
+            timed_out: true
+          })
+        }
+      ]
+    };
+  }
+  const matched = tokenised.find((o) => o.value === resolution.value);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          value: resolution.value,
+          label: matched?.label ?? resolution.value,
+          responded_by: resolution.respondedByUser,
+          responded_at: resolution.respondedAt,
+          timed_out: false
+        })
+      }
+    ]
+  };
+}
+function errResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
 var MAX_INBOUND_FILE_BYTES = 25 * 1024 * 1024;
 var SLACK_DOWNLOAD_TIMEOUT_MS = 15e3;
 var DOWNLOAD_ALLOWLIST_TTL_MS = 60 * 60 * 1e3;
@@ -15217,6 +16001,44 @@ async function connectSocketMode() {
       if (msg.envelope_id) {
         ws.send(JSON.stringify({ envelope_id: msg.envelope_id }));
       }
+      if (msg.type === "interactive" && msg.payload?.type === "block_actions") {
+        if (!interactiveHostAvailable()) {
+          process.stderr.write(
+            `slack-channel(${AGENT_CODE_NAME}): block_actions received but Block Kit + host MCP wiring missing \u2014 dropping
+`
+          );
+          return;
+        }
+        const action = msg.payload.actions?.[0];
+        if (!action || typeof action.action_id !== "string") return;
+        const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
+        const decoded = runtime.decodeActionId(action.action_id);
+        if (!decoded) {
+          return;
+        }
+        try {
+          await runtime.resolveInteractive(
+            {
+              apiHost: AGT_HOST,
+              apiKey: AGT_API_KEY,
+              agentId: AGT_AGENT_ID
+            },
+            {
+              callbackId: decoded.callbackId,
+              token: decoded.token,
+              respondedByUser: msg.payload.user?.id,
+              originalBlocks: msg.payload.message?.blocks,
+              responseUrl: msg.payload.response_url
+            }
+          );
+        } catch (err) {
+          process.stderr.write(
+            `slack-channel(${AGENT_CODE_NAME}): resolveInteractive failed for ${hashId(decoded.callbackId)}: ${err.message}
+`
+          );
+        }
+        return;
+      }
       if (msg.type !== "events_api" || !msg.payload?.event) return;
       const evt = msg.payload.event;
       if (evt.user === botUserId) return;