@integrity-labs/agt-cli 0.21.8 → 0.22.0

package/{mcp → dist/mcp}/telegram-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,433 @@ var require_dist = __commonJS({
   }
 });
 
+// src/ask-user-runtime.ts
+var ask_user_runtime_exports = {};
+__export(ask_user_runtime_exports, {
+  DEFAULT_ASK_USER_LIMITS: () => DEFAULT_ASK_USER_LIMITS,
+  apiCall: () => apiCall,
+  createPendingInteraction: () => createPendingInteraction,
+  generateOptionToken: () => generateOptionToken,
+  updatePendingInteractionMessageTs: () => updatePendingInteractionMessageTs,
+  validateAskUserOptions: () => validateAskUserOptions,
+  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 validateAskUserOptions(options, limits = DEFAULT_ASK_USER_LIMITS) {
+  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 > limits.maxOptions) {
+    errors.push({
+      path: "options",
+      message: `max ${limits.maxOptions} options`
+    });
+  }
+  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 > limits.maxLabelChars) {
+        errors.push({ path: `${path}.label`, message: `max ${limits.maxLabelChars} 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 > limits.maxValueChars) {
+        errors.push({ path: `${path}.value`, message: `max ${limits.maxValueChars} chars` });
+      }
+      if (seenValues.has(o.value)) errors.push({ path: `${path}.value`, message: "duplicate value" });
+      seenValues.add(o.value);
+    }
+  });
+  return { ok: errors.length === 0, errors };
+}
+var auth, API_FETCH_TIMEOUT_MS, DEFAULT_ASK_USER_LIMITS;
+var init_ask_user_runtime = __esm({
+  "src/ask-user-runtime.ts"() {
+    "use strict";
+    auth = { token: null, expiresAtEpochMs: 0 };
+    API_FETCH_TIMEOUT_MS = 1e4;
+    DEFAULT_ASK_USER_LIMITS = {
+      maxOptions: 5,
+      maxLabelChars: 75,
+      maxValueChars: 2e3
+    };
+  }
+});
+
+// src/slack-block-kit-runtime.ts
+var slack_block_kit_runtime_exports = {};
+__export(slack_block_kit_runtime_exports, {
+  DEFAULT_ASK_USER_LIMITS: () => DEFAULT_ASK_USER_LIMITS,
+  apiCall: () => apiCall,
+  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
+});
+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, "`type` is required and must be a string");
+      continue;
+    }
+    if (!SUPPORTED_BLOCK_TYPES.includes(type)) {
+      push(path, `unsupported block type "${type}" \u2014 supported: ${SUPPORTED_BLOCK_TYPES.join(", ")}`);
+      continue;
+    }
+    if ("block_id" in block && typeof block.block_id === "string" && block.block_id.length > SLACK_LIMITS.identifierChars) {
+      push(`${path}.block_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
+    }
+    if (type === "header") validateHeaderBlock(block, path, push);
+    else if (type === "section") validateSectionBlock(block, path, push);
+    else if (type === "context") validateContextBlock(block, path, push);
+    else if (type === "actions") validateActionsBlock(block, path, push);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function validateHeaderBlock(b, path, push) {
+  const text = b.text;
+  if (!text) {
+    push(`${path}.text`, "header requires a text object");
+    return;
+  }
+  validateTextObject(text, `${path}.text`, SLACK_LIMITS.headerTextChars, ["plain_text"], push);
+}
+function validateSectionBlock(b, path, push) {
+  const text = b.text;
+  const fields = b.fields;
+  if (!text && !fields) {
+    push(path, "section must have at least one of `text` or `fields`");
+    return;
+  }
+  if (text) {
+    validateTextObject(text, `${path}.text`, SLACK_LIMITS.sectionTextChars, ["plain_text", "mrkdwn"], push);
+  }
+  if (fields) {
+    if (!Array.isArray(fields)) {
+      push(`${path}.fields`, "`fields` must be an array");
+    } else if (fields.length > SLACK_LIMITS.sectionFields) {
+      push(`${path}.fields`, `max ${SLACK_LIMITS.sectionFields} fields`);
+    } else {
+      fields.forEach((f, i) => {
+        validateTextObject(f, `${path}.fields[${i}]`, SLACK_LIMITS.sectionFieldChars, ["plain_text", "mrkdwn"], push);
+      });
+    }
+  }
+}
+function validateContextBlock(b, path, push) {
+  const elements = b.elements;
+  if (!Array.isArray(elements) || elements.length === 0) {
+    push(`${path}.elements`, "context requires non-empty `elements` array");
+    return;
+  }
+  elements.forEach((el, i) => {
+    validateTextObject(el, `${path}.elements[${i}]`, SLACK_LIMITS.sectionTextChars, ["plain_text", "mrkdwn"], push);
+  });
+}
+function validateActionsBlock(b, path, push) {
+  const elements = b.elements;
+  if (!Array.isArray(elements) || elements.length === 0) {
+    push(`${path}.elements`, "actions requires non-empty `elements` array");
+    return;
+  }
+  if (elements.length > SLACK_LIMITS.actionElements) {
+    push(`${path}.elements`, `max ${SLACK_LIMITS.actionElements} elements`);
+  }
+  elements.forEach((el, i) => {
+    const type = el?.type;
+    if (typeof type !== "string") {
+      push(`${path}.elements[${i}]`, "each element must have a `type`");
+      return;
+    }
+    if (!SUPPORTED_ACTION_ELEMENTS.includes(type)) {
+      push(`${path}.elements[${i}]`, `unsupported action element "${type}" \u2014 supported: ${SUPPORTED_ACTION_ELEMENTS.join(", ")}`);
+      return;
+    }
+    if (type === "button") {
+      const text = el.text;
+      if (!text) {
+        push(`${path}.elements[${i}].text`, "button requires a text object");
+      } else {
+        validateTextObject(text, `${path}.elements[${i}].text`, SLACK_LIMITS.buttonLabelChars, ["plain_text"], push);
+      }
+      const actionId = el.action_id;
+      if (typeof actionId !== "string" || actionId.length === 0) {
+        push(`${path}.elements[${i}].action_id`, "button requires a non-empty `action_id`");
+      } else if (actionId.length > SLACK_LIMITS.identifierChars) {
+        push(`${path}.elements[${i}].action_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
+      }
+      const value = el.value;
+      if (value !== void 0) {
+        if (typeof value !== "string") {
+          push(`${path}.elements[${i}].value`, "`value` must be a string");
+        } else if (value.length > SLACK_LIMITS.optionValueChars) {
+          push(`${path}.elements[${i}].value`, `max ${SLACK_LIMITS.optionValueChars} chars`);
+        }
+      }
+    }
+  });
+}
+function validateTextObject(text, path, maxChars, allowedTypes, push) {
+  if (!text || typeof text !== "object") {
+    push(path, "must be an object with `type` and `text`");
+    return;
+  }
+  const t = text;
+  if (typeof t.type !== "string" || !allowedTypes.includes(t.type)) {
+    push(`${path}.type`, `must be one of: ${allowedTypes.join(", ")}`);
+  }
+  if (typeof t.text !== "string" || t.text.length === 0) {
+    push(`${path}.text`, "required non-empty string");
+  } else if (t.text.length > maxChars) {
+    push(`${path}.text`, `max ${maxChars} chars`);
+  }
+}
+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 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";
+    init_ask_user_runtime();
+    init_ask_user_runtime();
+    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"
@@ -15276,6 +15706,7 @@ var BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
 var AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME ?? "unknown";
 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 ALLOWED_CHATS = new Set(
   (process.env.TELEGRAM_ALLOWED_CHATS ?? "").split(",").map((s) => s.trim()).filter(Boolean)
 );
@@ -16081,7 +16512,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
     ...progressRegistry.getDefinitions(),
     {
       name: "channel_request_input",
-      description: "Generic Yes/No or multi-choice picker. NOT YET IMPLEMENTED for Telegram \u2014 call returns NotImplemented. Sibling follow-up to ENG-5392 will land the Telegram inline-keyboard renderer (parallel to the existing ENG-5021 ask_user work). Today the tool exists only so agents register a stable, channel-agnostic signature in their prompt and degrade gracefully.",
+      description: "Generic Yes/No or multi-choice picker. Renders as a Telegram inline keyboard; the tool blocks until the user taps an option (or the timeout elapses) and returns the resolved value. Use this when you need a structured pick rather than freeform text \u2014 e.g. confirming a draft action or disambiguating an ambiguous fork.",
       inputSchema: {
         type: "object",
         properties: {
@@ -16197,15 +16628,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   const progressResult = await progressRegistry.handle(name, args ?? {});
   if (progressResult !== void 0) return progressResult;
   if (name === "channel_request_input") {
-    return {
-      content: [
-        {
-          type: "text",
-          text: "NotImplemented: channel_request_input is not yet available on Telegram. Sibling follow-up to ENG-5392 will add the Telegram inline-keyboard renderer. For now, send a freeform telegram.reply asking the question and parse the reply text."
-        }
-      ],
-      isError: true
-    };
+    return handleChannelRequestInput(args ?? {});
   }
   if (name === "telegram.reply" || name === "telegram.send_message") {
     const { chat_id, text, reply_to_message_id } = args;
@@ -16400,6 +16823,228 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   }
   throw new Error(`Unknown tool: ${name}`);
 });
+function channelRequestInputAvailable() {
+  return Boolean(AGT_HOST && AGT_API_KEY && AGT_AGENT_ID);
+}
+function errResult2(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+async function handleChannelRequestInput(args) {
+  if (!channelRequestInputAvailable()) {
+    return errResult2(
+      "channel_request_input is disabled \u2014 missing AGT_HOST / AGT_API_KEY / AGT_AGENT_ID env wiring."
+    );
+  }
+  const runtime = await Promise.resolve().then(() => (init_ask_user_runtime(), ask_user_runtime_exports));
+  const { apiCall: apiCall2, waitForResolution: waitForResolution2, validateAskUserOptions: validateAskUserOptions2 } = runtime;
+  const { thread_id, prompt_text, options, schema, request_id, timeout_seconds } = args;
+  if (typeof thread_id !== "string" || !thread_id) {
+    return errResult2(
+      "thread_id is required (Telegram shape: `<chat_id>` or `<chat_id>:<reply_to_message_id>`)"
+    );
+  }
+  if (typeof prompt_text !== "string" || !prompt_text) {
+    return errResult2("prompt_text is required");
+  }
+  const optsValidation = validateAskUserOptions2(options, {
+    maxOptions: 4,
+    maxLabelChars: 75,
+    maxValueChars: 2e3
+  });
+  if (!optsValidation.ok) {
+    return errResult2(
+      `Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
+    );
+  }
+  const optionsArr = options;
+  if (optionsArr.length < 2) {
+    return errResult2(
+      "options must contain at least 2 entries (this is a picker, not a notification)"
+    );
+  }
+  if (!schema || typeof schema.type !== "string") {
+    return errResult2("schema is required with shape { type: 'yes_no' | 'choice' }");
+  }
+  if (schema.type !== "yes_no" && schema.type !== "choice") {
+    return errResult2("schema.type must be 'yes_no' or 'choice'");
+  }
+  if (schema.type === "yes_no" && optionsArr.length !== 2) {
+    return errResult2("schema.type='yes_no' requires exactly 2 options");
+  }
+  if (request_id !== void 0 && (typeof request_id !== "string" || !request_id)) {
+    return errResult2("request_id must be a non-empty string when provided");
+  }
+  const requestedTimeout = typeof timeout_seconds === "number" ? timeout_seconds : 300;
+  const timeoutSec = Math.max(10, Math.min(3600, requestedTimeout));
+  const cfg = {
+    apiHost: AGT_HOST,
+    apiKey: AGT_API_KEY,
+    agentId: AGT_AGENT_ID
+  };
+  let dispatchPayload;
+  try {
+    const res = await apiCall2(cfg, "POST", "/host/channel/request-input", {
+      agent_id: cfg.agentId,
+      thread_id,
+      prompt_text,
+      options: optionsArr,
+      schema,
+      ...request_id ? { request_id } : {}
+    });
+    dispatchPayload = await res.json().catch(() => ({}));
+    if (!res.ok || !dispatchPayload.ok || !dispatchPayload.callback_id) {
+      const reason = dispatchPayload.reason ?? `http_${res.status}`;
+      return errResult2(`channel_request_input dispatch failed: ${reason}`);
+    }
+  } catch (err) {
+    return errResult2(
+      `channel_request_input dispatch failed: ${err.message}`
+    );
+  }
+  const callbackId = dispatchPayload.callback_id;
+  const deadline = new Date(Date.now() + timeoutSec * 1e3);
+  const resolution = await waitForResolution2(cfg, callbackId, { deadline });
+  if (resolution.kind === "timeout") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            value: null,
+            clicked_by_user: null,
+            timed_out: true,
+            responded_at: null,
+            callback_id: callbackId
+          })
+        }
+      ]
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          value: resolution.value,
+          clicked_by_user: resolution.respondedByUser,
+          timed_out: false,
+          responded_at: resolution.respondedAt,
+          callback_id: callbackId
+        })
+      }
+    ]
+  };
+}
+async function handleCallbackQuery(cb) {
+  if (!channelRequestInputAvailable()) {
+    await ackCallbackQuery(cb.id, "Not configured").catch(() => {
+    });
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): callback_query received but host wiring missing \u2014 dropping
+`
+    );
+    return;
+  }
+  if (typeof cb.data !== "string" || !cb.data) {
+    await ackCallbackQuery(cb.id).catch(() => {
+    });
+    return;
+  }
+  const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
+  const decoded = runtime.decodeActionId(cb.data);
+  if (!decoded) {
+    await ackCallbackQuery(cb.id).catch(() => {
+    });
+    return;
+  }
+  await ackCallbackQuery(cb.id, "Got it").catch(() => {
+  });
+  const apiCallRuntime = await Promise.resolve().then(() => (init_ask_user_runtime(), ask_user_runtime_exports));
+  const cfg = {
+    apiHost: AGT_HOST,
+    apiKey: AGT_API_KEY,
+    agentId: AGT_AGENT_ID
+  };
+  let resolveResult;
+  try {
+    const res = await apiCallRuntime.apiCall(cfg, "POST", "/host/interactive/resolve", {
+      agent_id: cfg.agentId,
+      callback_id: decoded.callbackId,
+      token: decoded.token,
+      responded_by_user: String(cb.from.id)
+    });
+    resolveResult = await res.json().catch(() => ({}));
+    if (!res.ok || !resolveResult.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): /host/interactive/resolve returned non-ok (callback_id=${decoded.callbackId}, http=${res.status}, reason=${resolveResult.reason ?? "unknown"})
+`
+      );
+      await ackCallbackQuery(cb.id, "Could not record your choice").catch(() => {
+      });
+      return;
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): /host/interactive/resolve threw (callback_id=${decoded.callbackId}): ${err.message}
+`
+    );
+    await ackCallbackQuery(cb.id, "Could not record your choice").catch(() => {
+    });
+    return;
+  }
+  const confirmationLabel = "\u2713";
+  if (cb.message) {
+    try {
+      const resp = await telegramApiCall(
+        "editMessageReplyMarkup",
+        {
+          chat_id: cb.message.chat.id,
+          message_id: cb.message.message_id,
+          // Empty inline_keyboard removes the buttons but leaves the
+          // original prompt text intact. Less destructive than
+          // editMessageText, and the prompt remains scrollable history.
+          reply_markup: { inline_keyboard: [] }
+        },
+        5e3
+      );
+      if (!resp.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): editMessageReplyMarkup failed (callback_id=${decoded.callbackId}): ${resp.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): editMessageReplyMarkup threw (callback_id=${decoded.callbackId}): ${err.message}
+`
+      );
+    }
+    void confirmationLabel;
+  }
+}
+async function ackCallbackQuery(callbackQueryId, text) {
+  try {
+    const resp = await telegramApiCall(
+      "answerCallbackQuery",
+      {
+        callback_query_id: callbackQueryId,
+        ...text ? { text } : {}
+      },
+      5e3
+    );
+    if (!resp.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): answerCallbackQuery rejected (id=${callbackQueryId}): ${resp.description ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): answerCallbackQuery failed (id=${callbackQueryId}): ${err.message}
+`
+    );
+  }
+}
 await mcp.connect(new StdioServerTransport());
 var LONG_POLL_SECONDS = 50;
 var POLL_HTTP_TIMEOUT_MS = (LONG_POLL_SECONDS + 10) * 1e3;
@@ -16493,7 +17138,11 @@ async function pollLoop() {
         {
           offset: nextOffset,
           timeout: LONG_POLL_SECONDS,
-          allowed_updates: ["message"]
+          // ENG-5398: `callback_query` carries inline-keyboard taps from
+          // `channel_request_input`. Without it the buttons render fine
+          // but Telegram silently drops the tap and the agent's polling
+          // loop times out as if no-one ever pressed anything.
+          allowed_updates: ["message", "callback_query"]
         },
         POLL_HTTP_TIMEOUT_MS
       );
@@ -16503,11 +17152,20 @@ async function pollLoop() {
           `telegram-channel(${AGENT_CODE_NAME}): getUpdates failed: ${resp.description ?? "unknown"}
 `
         );
-        await sleep(5e3);
+        await sleep2(5e3);
         continue;
       }
       for (const update of resp.result ?? []) {
         nextOffset = Math.max(nextOffset, update.update_id + 1);
+        if (update.callback_query) {
+          await handleCallbackQuery(update.callback_query).catch((err) => {
+            process.stderr.write(
+              `telegram-channel(${AGENT_CODE_NAME}): callback_query handler crashed: ${err.message}
+`
+            );
+          });
+          continue;
+        }
         const msg = update.message;
         if (!msg) continue;
         const classifiedAttachments = classifyTelegramAttachments(msg);
@@ -16721,11 +17379,11 @@ async function pollLoop() {
         `telegram-channel(${AGENT_CODE_NAME}): poll error: ${err.message}
 `
       );
-      await sleep(5e3);
+      await sleep2(5e3);
     }
   }
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms).unref());
 }
 function shutdown(reason) {