@integrity-labs/agt-cli 0.27.15 → 0.27.17

package/dist/mcp/slack-channel.js

@@ -14447,468 +14447,6 @@ async function isThreadKilled(opts) {
   }
 }
 
-// src/slack-progress.ts
-var MODE_EMOJI = {
-  thinking: "\u{1F4AD}",
-  working: "\u{1F6E0}\uFE0F",
-  waiting: "\u23F3"
-};
-var TERMINAL_EMOJI = {
-  completed: "\u2705",
-  failed: "\u274C"
-};
-function formatWallClock(ms, timeZone) {
-  const fmt = new Intl.DateTimeFormat("en-GB", {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-    timeZone,
-    timeZoneName: "short"
-  });
-  const parts = fmt.formatToParts(new Date(ms));
-  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
-  return `${get("hour")}:${get("minute")}:${get("second")} ${get("timeZoneName")}`;
-}
-function renderHeaderLine(state) {
-  if (state.terminal) {
-    return `${TERMINAL_EMOJI[state.terminal.kind]} *${state.terminal.kind === "completed" ? "Done" : "Failed"}* \u2014 ${state.initialLabel}`;
-  }
-  return `${MODE_EMOJI[state.mode]} *Working on:* ${state.initialLabel}`;
-}
-function renderStepLine(state) {
-  if (state.terminal) {
-    return state.terminal.message ? state.terminal.message : void 0;
-  }
-  const parts = [];
-  if (state.stepNumber) {
-    if (state.stepNumber.total != null) {
-      parts.push(`*Step ${state.stepNumber.current} of ${state.stepNumber.total}*`);
-    } else {
-      parts.push(`*Step ${state.stepNumber.current}*`);
-    }
-  }
-  if (state.stepLabel) parts.push(state.stepLabel);
-  return parts.length > 0 ? parts.join(": ") : void 0;
-}
-function renderProgressBlocks(state) {
-  const header = renderHeaderLine(state);
-  const step = renderStepLine(state);
-  const footer = state.terminal ? `_${state.terminal.kind === "completed" ? "completed" : "failed"}: ${formatWallClock(state.lastChangeAt)}_` : `_last update: ${formatWallClock(state.lastChangeAt)}_`;
-  const lines = [header];
-  if (step) lines.push(step);
-  if (state.detail) lines.push(`_${state.detail}_`);
-  lines.push(footer);
-  const fallbackText = state.terminal ? `${state.terminal.kind === "completed" ? "Done" : "Failed"} \u2014 ${state.initialLabel}` : `Working on: ${state.initialLabel}`;
-  return {
-    text: fallbackText,
-    blocks: [
-      {
-        type: "section",
-        text: { type: "mrkdwn", text: lines.join("\n") }
-      }
-    ]
-  };
-}
-var SLACK_POST_URL = "https://slack.com/api/chat.postMessage";
-var SLACK_UPDATE_URL = "https://slack.com/api/chat.update";
-var DEFAULT_TIMEOUT_MS = 5e3;
-var SlackApiError = class extends Error {
-  constructor(endpoint, slackError, status) {
-    super(`Slack ${endpoint} failed: ${slackError} (status=${status})`);
-    this.endpoint = endpoint;
-    this.slackError = slackError;
-    this.status = status;
-    this.name = "SlackApiError";
-  }
-};
-function createSlackProgressFlush(opts) {
-  const fetchImpl = opts.fetchImpl ?? fetch;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  let anchorTs = null;
-  async function slackCall(endpoint, body) {
-    const url = endpoint === "chat.postMessage" ? SLACK_POST_URL : SLACK_UPDATE_URL;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let response;
-    try {
-      response = await fetchImpl(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${opts.botToken}`
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-    const parsed = await response.json().catch(() => ({ ok: false, error: "invalid_json" }));
-    if (!parsed.ok) {
-      throw new SlackApiError(endpoint, parsed.error ?? "unknown", response.status);
-    }
-    return parsed;
-  }
-  return async function flush(state) {
-    const payload = renderProgressBlocks(state);
-    if (anchorTs == null) {
-      const body = {
-        channel: opts.channel,
-        text: payload.text,
-        blocks: payload.blocks
-      };
-      if (opts.threadTs) body.thread_ts = opts.threadTs;
-      try {
-        const res = await slackCall("chat.postMessage", body);
-        if (!res.ts) {
-          throw new SlackApiError(
-            "chat.postMessage",
-            "missing ts in successful response",
-            200
-          );
-        }
-        anchorTs = res.ts;
-        opts.onAnchorPosted?.(res.ts);
-      } catch (err) {
-        throw err;
-      }
-      return;
-    }
-    try {
-      await slackCall("chat.update", {
-        channel: opts.channel,
-        ts: anchorTs,
-        text: payload.text,
-        blocks: payload.blocks
-      });
-    } catch (err) {
-      if (opts.onApiError && err instanceof SlackApiError) {
-        await opts.onApiError(err);
-        return;
-      }
-      throw err;
-    }
-  };
-}
-
-// src/progress-tools.ts
-import { randomUUID } from "crypto";
-
-// src/progress-handle.ts
-async function startProgressHandle(opts) {
-  const now = opts.now ?? (() => Date.now());
-  const setTimer = opts.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
-  const clearTimer = opts.clearTimer ?? ((id) => clearTimeout(id));
-  const debounceMs = opts.debounceMs ?? 1e3;
-  const onPostTerminalUpdate = opts.onPostTerminalUpdate ?? defaultPostTerminalWarn;
-  const state = {
-    initialLabel: opts.initialLabel,
-    mode: opts.initialMode ?? "working",
-    lastChangeAt: now()
-  };
-  let lastFlushAt = 0;
-  let pendingTimer = null;
-  let inFlight = null;
-  let terminal = false;
-  async function doFlush() {
-    while (inFlight) await inFlight;
-    if (pendingTimer != null) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    lastFlushAt = now();
-    const promise = opts.flush(snapshotState());
-    inFlight = promise.then(
-      () => {
-        inFlight = null;
-      },
-      (err) => {
-        inFlight = null;
-        throw err;
-      }
-    );
-    await inFlight;
-  }
-  function snapshotState() {
-    return {
-      initialLabel: state.initialLabel,
-      mode: state.mode,
-      stepLabel: state.stepLabel,
-      stepNumber: state.stepNumber ? { ...state.stepNumber } : void 0,
-      detail: state.detail,
-      lastChangeAt: state.lastChangeAt,
-      terminal: state.terminal ? { ...state.terminal } : void 0
-    };
-  }
-  function applyUpdate(next) {
-    if (next.mode !== void 0) state.mode = next.mode;
-    if (next.stepLabel !== void 0) state.stepLabel = next.stepLabel;
-    if (next.stepNumber !== void 0) state.stepNumber = { ...next.stepNumber };
-    if (next.detail !== void 0) state.detail = next.detail;
-    state.lastChangeAt = now();
-  }
-  async function scheduleOrFlush() {
-    const elapsed = now() - lastFlushAt;
-    if (elapsed >= debounceMs) {
-      await doFlush();
-      return;
-    }
-    if (pendingTimer != null) return;
-    const remaining = debounceMs - elapsed;
-    pendingTimer = setTimer(() => {
-      pendingTimer = null;
-      void doFlush().catch(() => {
-      });
-    }, remaining);
-  }
-  lastFlushAt = now();
-  await opts.flush(snapshotState());
-  return {
-    snapshot: snapshotState,
-    async update(next) {
-      if (terminal) {
-        const peeked = snapshotState();
-        Object.assign(peeked, {
-          mode: next.mode ?? peeked.mode,
-          stepLabel: next.stepLabel ?? peeked.stepLabel,
-          stepNumber: next.stepNumber ?? peeked.stepNumber,
-          detail: next.detail ?? peeked.detail
-        });
-        try {
-          onPostTerminalUpdate(peeked);
-        } catch (err) {
-          console.warn(
-            "[progress-handle] onPostTerminalUpdate threw \u2014 swallowed to keep update() non-throwing:",
-            err
-          );
-        }
-        return;
-      }
-      applyUpdate(next);
-      await scheduleOrFlush();
-    },
-    async complete(summary) {
-      if (terminal) return;
-      terminal = true;
-      state.terminal = { kind: "completed", message: summary };
-      state.lastChangeAt = now();
-      await doFlush();
-    },
-    async fail(reason) {
-      if (terminal) return;
-      terminal = true;
-      state.terminal = { kind: "failed", message: reason };
-      state.lastChangeAt = now();
-      await doFlush();
-    },
-    isTerminal: () => terminal
-  };
-}
-function defaultPostTerminalWarn(state) {
-  console.warn(
-    `[progress-handle] update() called after terminal transition (${state.terminal?.kind}) \u2014 ignored.`
-  );
-}
-
-// src/progress-tools.ts
-var ProgressToolRegistry = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.toolNames = {
-      start: `${opts.prefix}_progress_start`,
-      update: `${opts.prefix}_progress_update`,
-      complete: `${opts.prefix}_progress_complete`,
-      fail: `${opts.prefix}_progress_fail`
-    };
-  }
-  handles = /* @__PURE__ */ new Map();
-  toolNames;
-  /** Tool definitions to splice into the MCP ListToolsRequest response. */
-  getDefinitions() {
-    const { surfaceDescription, startArgsSchema } = this.opts;
-    const debounceMs = this.opts.debounceMs ?? 1e3;
-    const debounceText = debounceMs === 1e3 ? "per second" : `every ${debounceMs}ms`;
-    return [
-      {
-        name: this.toolNames.start,
-        description: `Post a "still working" anchor to ${surfaceDescription} and return a progress_id. The anchor message updates in place as you call ${this.toolNames.update} \u2014 operators see one message that ticks forward instead of a flood of new ones. Always end with ${this.toolNames.complete} or ${this.toolNames.fail}; otherwise the anchor lingers as "working" until the stale-state sweep flips it. Opt-in \u2014 only call this for tasks that will take more than a few seconds.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            label: {
-              type: "string",
-              description: 'Short top-line label for the task (e.g. "diagnose vigil"). Stays constant for the lifetime of this progress anchor.'
-            },
-            initial_mode: {
-              type: "string",
-              enum: ["thinking", "working", "waiting"],
-              description: 'Initial mode emoji \u2014 defaults to "working".'
-            },
-            ...startArgsSchema.properties
-          },
-          required: ["label", ...startArgsSchema.required]
-        }
-      },
-      {
-        name: this.toolNames.update,
-        description: `Update the progress anchor in place. The state machine debounces calls to one ${surfaceDescription} API call ${debounceText}, so spamming this every step is safe \u2014 only the latest pending state will paint. Any subset of fields can be passed; omitted ones retain their previous value.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string", description: "The progress_id returned from start." },
-            step_label: { type: "string", description: 'Short label for the current step (e.g. "Querying CloudWatch logs").' },
-            step_current: { type: "number", description: "1-based step counter \u2014 current." },
-            step_total: { type: "number", description: "Total steps if known. Omit for open-ended progress." },
-            mode: { type: "string", enum: ["thinking", "working", "waiting"] },
-            detail: { type: "string", description: "Free-text detail line under the step label." }
-          },
-          required: ["progress_id"]
-        }
-      },
-      {
-        name: this.toolNames.complete,
-        description: `Mark the progress anchor as \u2705 completed. Flushes any pending debounced state before painting the terminal banner \u2014 the operator never sees a stale "Step N" beside the \u2705. After this, the handle is dead; further updates are no-ops.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string" },
-            summary: { type: "string", description: "Optional one-line summary of what was achieved." }
-          },
-          required: ["progress_id"]
-        }
-      },
-      {
-        name: this.toolNames.fail,
-        description: `Mark the progress anchor as \u274C failed. Always include a one-sentence reason \u2014 the operator can't tell *why* from emoji alone. Same flush-then-paint behaviour as complete.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            progress_id: { type: "string" },
-            reason: { type: "string", description: "One-sentence failure reason." }
-          },
-          required: ["progress_id", "reason"]
-        }
-      }
-    ];
-  }
-  /**
-   * Dispatch a CallToolRequest. Returns `undefined` if the tool name
-   * isn't one of ours (so the caller can keep walking its dispatch
-   * chain). Returns a tool result otherwise.
-   */
-  async handle(name, args) {
-    if (name === this.toolNames.start) return this.handleStart(args);
-    if (name === this.toolNames.update) return this.handleUpdate(args);
-    if (name === this.toolNames.complete) return this.handleComplete(args);
-    if (name === this.toolNames.fail) return this.handleFail(args);
-    return void 0;
-  }
-  /** Live count of in-flight handles. Exposed for tests + diagnostics. */
-  size() {
-    return this.handles.size;
-  }
-  async handleStart(args) {
-    const label = typeof args.label === "string" ? args.label : null;
-    if (!label) return errResult(`${this.toolNames.start}: 'label' must be a non-empty string`);
-    if ("initial_mode" in args && !isMode(args.initial_mode)) {
-      return errResult(
-        `${this.toolNames.start}: 'initial_mode' must be one of 'thinking', 'working', or 'waiting'`
-      );
-    }
-    for (const k of this.opts.startArgsSchema.required) {
-      if (typeof args[k] !== "string" || args[k].length === 0) {
-        return errResult(`${this.toolNames.start}: '${k}' must be a non-empty string`);
-      }
-    }
-    const initialMode = isMode(args.initial_mode) ? args.initial_mode : void 0;
-    const progressId = randomUUID();
-    try {
-      const flush = this.opts.createFlush(args);
-      const handle = await startProgressHandle({
-        initialLabel: label,
-        initialMode,
-        flush,
-        debounceMs: this.opts.debounceMs ?? 1e3
-      });
-      this.handles.set(progressId, handle);
-      return okResult(JSON.stringify({ progress_id: progressId }));
-    } catch (err) {
-      return errResult(`${this.toolNames.start} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleUpdate(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.update}: 'progress_id' must be a string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.update}: unknown progress_id (already terminated, or never started)`);
-    if ("mode" in args && !isMode(args.mode)) {
-      return errResult(
-        `${this.toolNames.update}: 'mode' must be one of 'thinking', 'working', or 'waiting'`
-      );
-    }
-    if (typeof args.step_total === "number" && typeof args.step_current !== "number") {
-      return errResult(
-        `${this.toolNames.update}: 'step_total' requires 'step_current'`
-      );
-    }
-    const next = {};
-    if (typeof args.step_label === "string") next.stepLabel = args.step_label;
-    if (typeof args.step_current === "number") {
-      next.stepNumber = {
-        current: args.step_current,
-        ...typeof args.step_total === "number" ? { total: args.step_total } : {}
-      };
-    }
-    if (isMode(args.mode)) next.mode = args.mode;
-    if (typeof args.detail === "string") next.detail = args.detail;
-    try {
-      await handle.update(next);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.update} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleComplete(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.complete}: 'progress_id' must be a string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.complete}: unknown progress_id`);
-    const summary = typeof args.summary === "string" ? args.summary : void 0;
-    try {
-      await handle.complete(summary);
-      this.handles.delete(id);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.complete} failed: ${err.message ?? String(err)}`);
-    }
-  }
-  async handleFail(args) {
-    const id = typeof args.progress_id === "string" ? args.progress_id : null;
-    if (!id) return errResult(`${this.toolNames.fail}: 'progress_id' must be a string`);
-    const reason = typeof args.reason === "string" ? args.reason : null;
-    if (!reason) return errResult(`${this.toolNames.fail}: 'reason' must be a non-empty string`);
-    const handle = this.handles.get(id);
-    if (!handle) return errResult(`${this.toolNames.fail}: unknown progress_id`);
-    try {
-      await handle.fail(reason);
-      this.handles.delete(id);
-      return okResult("ok");
-    } catch (err) {
-      return errResult(`${this.toolNames.fail} failed: ${err.message ?? String(err)}`);
-    }
-  }
-};
-function okResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-function errResult(text) {
-  return { content: [{ type: "text", text }], isError: true };
-}
-function isMode(value) {
-  return value === "thinking" || value === "working" || value === "waiting";
-}
-
 // src/slack-thread-context.ts
 var SLACK_AUTOLOAD_THREAD_LIMIT = 30;
 var SLACK_AUTOLOAD_THREAD_MAX_CHARS = 4e3;
@@ -15122,7 +14660,7 @@ import {
 } from "fs";
 import { basename, join as join4, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { createHash, randomUUID } from "crypto";
 
 // src/slack-thread-store.ts
 import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
@@ -16548,7 +16086,7 @@ async function handleSlashCommandEnvelope(payload) {
           ...payload.thread_ts ? { thread_ts: payload.thread_ts } : {}
         }
       };
-      const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+      const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
       writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
       renameSync2(tmpPath, flagPath);
       process.stderr.write(
@@ -16656,7 +16194,7 @@ async function handleRestartCommand(opts) {
         message_ts: opts.ts
       }
     };
-    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
     writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync2(tmpPath, flagPath);
     process.stderr.write(
@@ -16826,7 +16364,6 @@ var mcp = new Server(
       // 2048 chars, so anything appended late silently disappears.
       "CRITICAL: every response to a Slack <channel> tag MUST go through slack.reply. Text in your session WITHOUT a slack.reply call never reaches the user \u2014 the message dies inside the agent process.",
       `Inbound: <channel ... thread_ts="..." [thread_context="..."]>. Pass channel + thread_ts to slack.reply on threads. thread_context = thread pre-loaded; ground replies ONLY in it, never another channel's.`,
-      "Long task (3+ tool calls or >5s)? slack_progress_start (channel + thread_ts), slack_progress_update between steps, slack_progress_complete/_fail to close. One anchor edits in place; avoids thread spam. Not for one-shots.",
       "Inbound attachments: <channel> `files` is a JSON-serialised array \u2014 JSON.parse it. If an entry has `path`, the image is already downloaded \u2014 Read it directly, do NOT call slack.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, csv): pass file_id + channel verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Don't surface internal file-handling errors that don't affect the answer.",
       "Address users by user_name, never by raw user ID. In multi-participant threads the CURRENT speaker is the one on the latest <channel> tag.",
       'Mentioned in a channel \u2192 respond in that thread. DM \u2192 respond directly. auto_followed="true" \u2192 only reply if useful, OR if your own bot user is @-mentioned (counts even in auto_followed).',
@@ -16836,31 +16373,8 @@ var mcp = new Server(
     ].join(" ")
   }
 );
-var progressRegistry = new ProgressToolRegistry({
-  prefix: "slack",
-  surfaceDescription: "a Slack thread",
-  startArgsSchema: {
-    properties: {
-      channel: {
-        type: "string",
-        description: "Slack channel id (from the `channel` attribute on the inbound <channel> tag)."
-      },
-      thread_ts: {
-        type: "string",
-        description: "Thread `ts` so the anchor lands in the same thread as the request (from the `thread_ts` attribute on the inbound <channel> tag). Omit to post at channel-root."
-      }
-    },
-    required: ["channel"]
-  },
-  createFlush: (args) => createSlackProgressFlush({
-    botToken: BOT_TOKEN,
-    channel: args.channel,
-    threadTs: typeof args.thread_ts === "string" ? args.thread_ts : void 0
-  })
-});
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
-    ...progressRegistry.getDefinitions(),
     {
       name: "slack.reply",
       description: "Send a message back to a Slack channel or thread",
@@ -17111,8 +16625,6 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   if (isImpersonating() && !channelsEnabledOverride() && SLACK_EGRESS_TOOLS.has(name)) {
     return buildImpersonationRefusal(name);
   }
-  const progressResult = await progressRegistry.handle(name, args ?? {});
-  if (progressResult !== void 0) return progressResult;
   if (name === "slack.reply") {
     const { channel, text, thread_ts } = args;
     if (channel && thread_ts) {
@@ -17633,15 +17145,15 @@ async function handleSendStructured(args) {
   const { validateSlackBlocks: validateSlackBlocks2 } = runtime;
   const { channel, blocks, text, thread_ts, interactive } = args;
   if (typeof channel !== "string" || !channel) {
-    return errResult2("channel is required");
+    return errResult("channel is required");
   }
   if (typeof text !== "string" || !text) {
-    return errResult2("text is required (used as fallback for push notifications and unfurls)");
+    return errResult("text is required (used as fallback for push notifications and unfurls)");
   }
   noteThreadActivity(channel, thread_ts);
   const validation = validateSlackBlocks2(blocks);
   if (!validation.ok) {
-    return errResult2(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+    return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
   }
   let effectiveBlocks = blocks;
   let ratingCallbackId = null;
@@ -17649,13 +17161,13 @@ async function handleSendStructured(args) {
   let ratingTokenised = [];
   if (interactive) {
     if (interactive.type !== "rate_run") {
-      return errResult2(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
+      return errResult(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
     }
     if (typeof interactive.run_id !== "string" || !interactive.run_id) {
-      return errResult2("interactive.run_id is required when interactive is set");
+      return errResult("interactive.run_id is required when interactive is set");
     }
     if (!interactiveHostAvailable()) {
-      return errResult2(
+      return errResult(
         "interactive=rate_run requires Block Kit plus host MCP wiring (AGT_HOST, AGT_API_KEY, AGT_AGENT_ID)."
       );
     }
@@ -17686,7 +17198,7 @@ async function handleSendStructured(args) {
     effectiveBlocks = [...blocks, ratingBlock];
     const finalValidation = runtime.validateSlackBlocks(effectiveBlocks);
     if (!finalValidation.ok) {
-      return errResult2(
+      return errResult(
         `Invalid blocks (after appending rating row): ${finalValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
       );
     }
@@ -17707,7 +17219,7 @@ async function handleSendStructured(args) {
         kindData: { run_id: interactive.run_id, scale }
       });
     } catch (err) {
-      return errResult2(`Failed to register rating row: ${err.message}`);
+      return errResult(`Failed to register rating row: ${err.message}`);
     }
   }
   const result = await postSlackMessageWithTs({
@@ -17717,7 +17229,7 @@ async function handleSendStructured(args) {
     ...thread_ts ? { thread_ts } : {}
   });
   if (!result.ok || !result.ts) {
-    return errResult2(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
+    return errResult(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
   }
   if (ratingCallbackId) {
     try {
@@ -17772,17 +17284,17 @@ async function handleSendStructured(args) {
 }
 async function handleAskUser(args) {
   if (!askUserToolAvailable()) {
-    return errResult2("slack.ask_user is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring.");
+    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 errResult2("channel is required");
-  if (typeof question !== "string" || !question) return errResult2("question is required");
+  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 errResult2(`Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+    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));
@@ -17815,7 +17327,7 @@ async function handleAskUser(args) {
       expiresAt
     });
   } catch (err) {
-    return errResult2(`Failed to register pending interaction: ${err.message}`);
+    return errResult(`Failed to register pending interaction: ${err.message}`);
   }
   const slackResult = await postSlackMessageWithTs({
     channel,
@@ -17825,7 +17337,7 @@ async function handleAskUser(args) {
     ...thread_ts ? { thread_ts } : {}
   });
   if (!slackResult.ok || !slackResult.ts) {
-    return errResult2(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
+    return errResult(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
   }
   try {
     await runtime.updatePendingInteractionMessageTs(cfg, callbackId, slackResult.ts);
@@ -17872,7 +17384,7 @@ async function handleAskUser(args) {
 }
 async function handleChannelRequestInput(args) {
   if (!askUserToolAvailable()) {
-    return errResult2(
+    return errResult(
       "channel_request_input is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring."
     );
   }
@@ -17880,10 +17392,10 @@ async function handleChannelRequestInput(args) {
   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 (shape: `<channel_id>:<thread_ts>`)");
+    return errResult("thread_id is required (shape: `<channel_id>:<thread_ts>`)");
   }
   if (typeof prompt_text !== "string" || !prompt_text) {
-    return errResult2("prompt_text is required");
+    return errResult("prompt_text is required");
   }
   const optsValidation = validateAskUserOptions2(options, {
     maxOptions: 4,
@@ -17891,25 +17403,25 @@ async function handleChannelRequestInput(args) {
     maxValueChars: 2e3
   });
   if (!optsValidation.ok) {
-    return errResult2(
+    return errResult(
       `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)");
+    return errResult("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' }");
+    return errResult("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'");
+    return errResult("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");
+    return errResult("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");
+    return errResult("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));
@@ -17931,10 +17443,10 @@ async function handleChannelRequestInput(args) {
     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}`);
+      return errResult(`channel_request_input dispatch failed: ${reason}`);
     }
   } catch (err) {
-    return errResult2(
+    return errResult(
       `channel_request_input dispatch failed: ${err.message}`
     );
   }
@@ -17972,7 +17484,7 @@ async function handleChannelRequestInput(args) {
     ]
   };
 }
-function errResult2(text) {
+function errResult(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
 var MAX_INBOUND_FILE_BYTES = 25 * 1024 * 1024;