opencode-router 0.11.128 → 0.11.130

package/dist/delivery.js

@@ -0,0 +1,108 @@
+const RETRYABLE_NETWORK_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EAI_AGAIN",
+    "ENOTFOUND",
+    "ETIMEDOUT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+]);
+function coerceStatus(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const record = error;
+    const maybe = [
+        record.status,
+        record.statusCode,
+        record.error_code,
+        record.response?.status,
+        record.data?.status,
+    ];
+    for (const value of maybe) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function coerceCode(error) {
+    if (!error || typeof error !== "object")
+        return "";
+    const code = error.code;
+    return typeof code === "string" ? code.trim().toUpperCase() : "";
+}
+function coerceMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    return "Unknown delivery error";
+}
+export function classifyDeliveryError(error) {
+    const status = coerceStatus(error);
+    const code = coerceCode(error);
+    const message = coerceMessage(error);
+    const lower = message.toLowerCase();
+    if (status === 401 || lower.includes("invalid_auth") || lower.includes("unauthorized")) {
+        return { code: "auth", message, retryable: false, status };
+    }
+    if (status === 403 || lower.includes("forbidden") || lower.includes("not_in_channel")) {
+        return { code: "forbidden", message, retryable: false, status };
+    }
+    if (status === 404 || lower.includes("chat not found") || lower.includes("channel_not_found")) {
+        return { code: "not_found", message, retryable: false, status };
+    }
+    if (status === 400 && (lower.includes("chat_id") || lower.includes("invalid peer") || lower.includes("invalid slack peer"))) {
+        return { code: "invalid_target", message, retryable: false, status };
+    }
+    if (status === 429 || lower.includes("rate limit") || lower.includes("too many requests")) {
+        return { code: "rate_limited", message, retryable: true, status };
+    }
+    if (status === 413 || lower.includes("too large") || lower.includes("file_too_large")) {
+        return { code: "payload_too_large", message, retryable: false, status };
+    }
+    if (lower.includes("unsupported") || lower.includes("cannot upload") || lower.includes("not allowed for this message type")) {
+        return { code: "unsupported_media", message, retryable: false, status };
+    }
+    if (status === 408 || lower.includes("timeout") || lower.includes("timed out")) {
+        return { code: "timeout", message, retryable: true, status };
+    }
+    if ((status !== undefined && status >= 500) || RETRYABLE_NETWORK_CODES.has(code) || lower.includes("fetch failed")) {
+        return { code: "network", message, retryable: true, status };
+    }
+    return { code: "unknown", message, retryable: false, status };
+}
+function withJitter(baseMs) {
+    const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(baseMs * 0.2)));
+    return baseMs + jitter;
+}
+export async function withDeliveryRetry(operation, run, options = {}) {
+    const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+    const baseDelayMs = Math.max(50, options.baseDelayMs ?? 250);
+    const maxDelayMs = Math.max(baseDelayMs, options.maxDelayMs ?? 4_000);
+    let attempt = 0;
+    for (;;) {
+        attempt += 1;
+        try {
+            return await run();
+        }
+        catch (error) {
+            const classified = classifyDeliveryError(error);
+            if (!classified.retryable || attempt >= maxAttempts) {
+                throw error;
+            }
+            const delayMs = Math.min(maxDelayMs, withJitter(baseDelayMs * 2 ** (attempt - 1)));
+            options.logger?.warn?.({
+                operation,
+                attempt,
+                maxAttempts,
+                delayMs,
+                code: classified.code,
+                status: classified.status,
+                message: classified.message,
+            }, "delivery operation failed; retrying");
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+}

package/dist/health.js

@@ -439,9 +439,15 @@ export async function startHealthServer(port, getStatus, logger, handlers = {})
                     const peerId = typeof payload.peerId === "string" ? payload.peerId.trim() : "";
                     const autoBind = payload.autoBind === true;
                     const text = typeof payload.text === "string" ? payload.text : "";
-                    if (!channel || !text.trim() || (!directory && !peerId)) {
+                    const parts = Array.isArray(payload.parts) ? payload.parts : undefined;
+                    const hasText = text.trim().length > 0;
+                    const hasParts = Array.isArray(parts) && parts.length > 0;
+                    if (!channel || (!hasText && !hasParts) || (!directory && !peerId)) {
                         res.writeHead(400, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ ok: false, error: "channel, text, and either directory or peerId are required" }));
+                        res.end(JSON.stringify({
+                            ok: false,
+                            error: "channel, at least one of text/parts, and either directory or peerId are required",
+                        }));
                         return;
                     }
                     const result = await handlers.sendMessage({
@@ -450,7 +456,8 @@ export async function startHealthServer(port, getStatus, logger, handlers = {})
                         ...(directory ? { directory } : {}),
                         ...(peerId ? { peerId } : {}),
                         ...(autoBind ? { autoBind: true } : {}),
-                        text,
+                        ...(hasText ? { text } : {}),
+                        ...(hasParts ? { parts } : {}),
                     });
                     res.writeHead(200, { "Content-Type": "application/json" });
                     res.end(JSON.stringify({ ok: true, ...result }));

package/dist/media-store.js

@@ -0,0 +1,125 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+function sanitizeSegment(value) {
+    const safe = value.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+    return safe || "unknown";
+}
+function extensionFromMime(mimeType, kind) {
+    const value = (mimeType ?? "").toLowerCase();
+    if (value === "image/jpeg")
+        return ".jpg";
+    if (value === "image/png")
+        return ".png";
+    if (value === "image/webp")
+        return ".webp";
+    if (value === "audio/ogg")
+        return ".ogg";
+    if (value === "audio/mpeg")
+        return ".mp3";
+    if (value === "audio/mp4")
+        return ".m4a";
+    if (value === "application/pdf")
+        return ".pdf";
+    if (kind === "image")
+        return ".jpg";
+    if (kind === "audio")
+        return ".ogg";
+    return ".bin";
+}
+function sanitizeFilename(filename, fallbackPrefix, fallbackExt) {
+    const trimmed = filename.trim();
+    if (!trimmed)
+        return `${fallbackPrefix}${fallbackExt}`;
+    const base = basename(trimmed)
+        .replace(/[^a-zA-Z0-9_.-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!base)
+        return `${fallbackPrefix}${fallbackExt}`;
+    if (extname(base))
+        return base;
+    return `${base}${fallbackExt}`;
+}
+export class MediaStore {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    async ensureReady() {
+        await mkdir(this.rootDir, { recursive: true });
+    }
+    inboundDir(channel, identityId, peerId) {
+        const now = new Date();
+        const day = now.toISOString().slice(0, 10);
+        return join(this.rootDir, "inbound", day, sanitizeSegment(channel), sanitizeSegment(identityId), sanitizeSegment(peerId));
+    }
+    async saveInboundBuffer(input) {
+        const dir = this.inboundDir(input.channel, input.identityId, input.peerId);
+        await mkdir(dir, { recursive: true });
+        const defaultExt = extensionFromMime(input.mimeType, input.kind);
+        const safeFilename = sanitizeFilename(input.filename ?? "", `${input.kind}-${Date.now()}-${randomUUID().slice(0, 8)}`, defaultExt);
+        const filePath = join(dir, safeFilename);
+        await writeFile(filePath, input.buffer);
+        return {
+            filePath,
+            filename: safeFilename,
+            sizeBytes: input.buffer.byteLength,
+            ...(input.mimeType ? { mimeType: input.mimeType } : {}),
+        };
+    }
+    async downloadInbound(input) {
+        const response = await fetch(input.url, {
+            headers: input.headers,
+        });
+        if (!response.ok) {
+            const error = new Error(`Failed to download media (${response.status})`);
+            error.status = response.status;
+            throw error;
+        }
+        const mimeType = input.mimeType || response.headers.get("content-type") || undefined;
+        const arrayBuffer = await response.arrayBuffer();
+        return this.saveInboundBuffer({
+            channel: input.channel,
+            identityId: input.identityId,
+            peerId: input.peerId,
+            kind: input.kind,
+            buffer: new Uint8Array(arrayBuffer),
+            ...(input.filename ? { filename: input.filename } : {}),
+            ...(mimeType ? { mimeType } : {}),
+        });
+    }
+    async resolveOutboundFile(input) {
+        const raw = input.filePath.trim();
+        if (!raw) {
+            const error = new Error("filePath is required");
+            error.status = 400;
+            throw error;
+        }
+        const resolved = isAbsolute(raw) ? resolve(raw) : resolve(input.baseDirectory, raw);
+        let info;
+        try {
+            info = await stat(resolved);
+        }
+        catch (error) {
+            const wrapped = new Error(`File not found: ${resolved}`);
+            wrapped.status = 404;
+            wrapped.cause = error;
+            throw wrapped;
+        }
+        if (!info.isFile()) {
+            const error = new Error(`Not a file: ${resolved}`);
+            error.status = 400;
+            throw error;
+        }
+        if (typeof input.maxBytes === "number" && Number.isFinite(input.maxBytes) && info.size > input.maxBytes) {
+            const error = new Error(`File exceeds maximum allowed size (${info.size} > ${Math.floor(input.maxBytes)} bytes): ${resolved}`);
+            error.status = 413;
+            throw error;
+        }
+        return {
+            filePath: resolved,
+            filename: basename(resolved),
+            sizeBytes: info.size,
+        };
+    }
+}

package/dist/media.js

@@ -0,0 +1,111 @@
+import { basename } from "node:path";
+function asTrimmedString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function parseTextPart(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record.type !== "text")
+        return null;
+    const text = typeof record.text === "string" ? record.text : "";
+    if (!text.trim())
+        return null;
+    return { type: "text", text };
+}
+function parseMediaPart(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record.type !== "image" && record.type !== "audio" && record.type !== "file")
+        return null;
+    const filePath = asTrimmedString(record.filePath);
+    if (!filePath)
+        return null;
+    const caption = typeof record.caption === "string" ? record.caption : undefined;
+    const filename = asTrimmedString(record.filename) || undefined;
+    const mimeType = asTrimmedString(record.mimeType) || undefined;
+    return {
+        type: record.type,
+        filePath,
+        ...(caption ? { caption } : {}),
+        ...(filename ? { filename } : {}),
+        ...(mimeType ? { mimeType } : {}),
+    };
+}
+export function normalizeOutboundParts(input) {
+    const normalized = [];
+    const text = typeof input.text === "string" ? input.text : "";
+    if (text.trim()) {
+        normalized.push({ type: "text", text });
+    }
+    if (Array.isArray(input.parts)) {
+        for (const item of input.parts) {
+            const textPart = parseTextPart(item);
+            if (textPart) {
+                normalized.push(textPart);
+                continue;
+            }
+            const mediaPart = parseMediaPart(item);
+            if (mediaPart) {
+                normalized.push(mediaPart);
+            }
+        }
+    }
+    return normalized;
+}
+export function textFromInboundParts(parts, fallbackText = "") {
+    if (!Array.isArray(parts) || parts.length === 0)
+        return fallbackText;
+    const texts = parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .filter((value) => value.trim().length > 0);
+    if (texts.length === 0)
+        return fallbackText;
+    return texts.join("\n");
+}
+function formatBytes(sizeBytes) {
+    if (typeof sizeBytes !== "number" || !Number.isFinite(sizeBytes) || sizeBytes < 0)
+        return "";
+    if (sizeBytes < 1024)
+        return `${sizeBytes}B`;
+    if (sizeBytes < 1024 * 1024)
+        return `${(sizeBytes / 1024).toFixed(1)}KB`;
+    return `${(sizeBytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+export function summarizeInboundPartsForPrompt(parts) {
+    if (!Array.isArray(parts) || parts.length === 0)
+        return [];
+    const mediaParts = parts.filter((part) => part.type === "media");
+    if (mediaParts.length === 0)
+        return [];
+    return mediaParts.map((part, index) => {
+        const media = part.media;
+        const label = `[${media.kind}]`;
+        const filename = media.filename || (media.filePath ? basename(media.filePath) : "(unnamed)");
+        const details = [];
+        if (media.mimeType)
+            details.push(media.mimeType);
+        const prettySize = formatBytes(media.sizeBytes);
+        if (prettySize)
+            details.push(prettySize);
+        if (media.status === "ready") {
+            const pathLabel = media.filePath ? `path=${media.filePath}` : "path=(missing)";
+            if (part.caption?.trim())
+                details.push(`caption=${JSON.stringify(part.caption.trim())}`);
+            details.push(pathLabel);
+            return `${index + 1}. ${label} ${filename}${details.length ? ` (${details.join(", ")})` : ""}`;
+        }
+        const reason = media.error?.trim() || "download failed";
+        return `${index + 1}. ${label} ${filename} (failed: ${reason})`;
+    });
+}
+export function summarizeInboundPartsForReporter(parts) {
+    if (!Array.isArray(parts) || parts.length === 0)
+        return "";
+    const mediaCount = parts.filter((part) => part.type === "media").length;
+    if (!mediaCount)
+        return "";
+    return mediaCount === 1 ? "[1 media attachment]" : `[${mediaCount} media attachments]`;
+}

package/dist/slack.js

@@ -1,5 +1,8 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
 import { SocketModeClient } from "@slack/socket-mode";
 import { WebClient } from "@slack/web-api";
+import { classifyDeliveryError, withDeliveryRetry } from "./delivery.js";
 // `peerId` encoding:
 // - DMs:   D12345678
 // - Threads in channels: C12345678|1700000000.000100
@@ -28,7 +31,7 @@ export function stripSlackMention(text, botUserId) {
     return next.trim();
 }
 const MAX_TEXT_LENGTH = 39_000;
-export function createSlackAdapter(identity, config, logger, onMessage, deps = { WebClient, SocketModeClient }) {
+export function createSlackAdapter(identity, config, logger, onMessage, deps = { WebClient, SocketModeClient }, mediaStore) {
     const botToken = identity.botToken?.trim() ?? "";
     const appToken = identity.appToken?.trim() ?? "";
     if (!botToken) {
@@ -42,6 +45,105 @@ export function createSlackAdapter(identity, config, logger, onMessage, deps = {
     const socket = new deps.SocketModeClient({ appToken });
     let botUserId = null;
     let started = false;
+    const parseSlackFiles = (value) => {
+        if (!Array.isArray(value))
+            return [];
+        const files = [];
+        for (const item of value) {
+            if (!item || typeof item !== "object")
+                continue;
+            const record = item;
+            const id = typeof record.id === "string" ? record.id : "";
+            const url = typeof record.url_private_download === "string"
+                ? record.url_private_download
+                : typeof record.url_private === "string"
+                    ? record.url_private
+                    : "";
+            if (!id || !url)
+                continue;
+            const mimeType = typeof record.mimetype === "string" ? record.mimetype : undefined;
+            const kind = typeof mimeType === "string" && mimeType.startsWith("image/")
+                ? "image"
+                : typeof mimeType === "string" && mimeType.startsWith("audio/")
+                    ? "audio"
+                    : "file";
+            files.push({
+                id,
+                url,
+                kind,
+                ...(typeof record.name === "string" ? { filename: record.name } : {}),
+                ...(mimeType ? { mimeType } : {}),
+                ...(typeof record.size === "number" ? { sizeBytes: record.size } : {}),
+            });
+        }
+        return files;
+    };
+    const downloadSlackFile = async (peerId, candidate) => {
+        if (!mediaStore) {
+            return {
+                type: "media",
+                media: {
+                    id: candidate.id,
+                    kind: candidate.kind,
+                    source: "slack",
+                    status: "failed",
+                    ...(candidate.filename ? { filename: candidate.filename } : {}),
+                    ...(candidate.mimeType ? { mimeType: candidate.mimeType } : {}),
+                    ...(typeof candidate.sizeBytes === "number" ? { sizeBytes: candidate.sizeBytes } : {}),
+                    providerFileId: candidate.id,
+                    providerUrl: candidate.url,
+                    error: "media store unavailable",
+                },
+            };
+        }
+        try {
+            const stored = await withDeliveryRetry("slack.download", () => mediaStore.downloadInbound({
+                channel: "slack",
+                identityId: identity.id,
+                peerId,
+                kind: candidate.kind,
+                url: candidate.url,
+                headers: {
+                    Authorization: `Bearer ${botToken}`,
+                },
+                ...(candidate.filename ? { filename: candidate.filename } : {}),
+                ...(candidate.mimeType ? { mimeType: candidate.mimeType } : {}),
+            }), { logger: log });
+            return {
+                type: "media",
+                media: {
+                    id: candidate.id,
+                    kind: candidate.kind,
+                    source: "slack",
+                    status: "ready",
+                    filePath: stored.filePath,
+                    filename: stored.filename,
+                    ...(stored.mimeType ? { mimeType: stored.mimeType } : {}),
+                    sizeBytes: stored.sizeBytes,
+                    providerFileId: candidate.id,
+                    providerUrl: candidate.url,
+                },
+            };
+        }
+        catch (error) {
+            const classified = classifyDeliveryError(error);
+            return {
+                type: "media",
+                media: {
+                    id: candidate.id,
+                    kind: candidate.kind,
+                    source: "slack",
+                    status: "failed",
+                    ...(candidate.filename ? { filename: candidate.filename } : {}),
+                    ...(candidate.mimeType ? { mimeType: candidate.mimeType } : {}),
+                    ...(typeof candidate.sizeBytes === "number" ? { sizeBytes: candidate.sizeBytes } : {}),
+                    providerFileId: candidate.id,
+                    providerUrl: candidate.url,
+                    error: `${classified.code}: ${classified.message}`,
+                },
+            };
+        }
+    };
     const safeAck = async (ack) => {
         if (typeof ack !== "function")
             return;
@@ -58,16 +160,20 @@ export function createSlackAdapter(identity, config, logger, onMessage, deps = {
         const userId = typeof event.user === "string" ? event.user : null;
         const botId = typeof event.bot_id === "string" ? event.bot_id : null;
         const subtype = typeof event.subtype === "string" ? event.subtype : null;
+        const files = parseSlackFiles(event.files);
+        const hasFiles = files.length > 0;
+        const threadTs = typeof event.thread_ts === "string" ? event.thread_ts : null;
+        const ts = typeof event.ts === "string" ? event.ts : null;
         // Avoid loops / non-user messages.
         if (botId)
             return { ok: true };
-        if (subtype && subtype !== "")
+        if (subtype && subtype !== "" && subtype !== "file_share")
             return { ok: true };
         if (userId && botUserId && userId === botUserId)
             return { ok: true };
-        if (!channelId || !textRaw.trim())
+        if (!channelId || (!textRaw.trim() && !hasFiles))
             return { ok: true };
-        return { ok: false, channelId, textRaw, userId };
+        return { ok: false, channelId, textRaw, userId, files, threadTs, ts };
     };
     socket.on("message", async (args) => {
         const ack = args?.ack;
@@ -82,14 +188,28 @@ export function createSlackAdapter(identity, config, logger, onMessage, deps = {
         const isDm = filtered.channelId.startsWith("D");
         if (!isDm)
             return;
-        const threadTs = typeof event.thread_ts === "string" ? event.thread_ts : null;
-        const peerId = formatSlackPeerId({ channelId: filtered.channelId, ...(threadTs ? { threadTs } : {}) });
+        const peerId = formatSlackPeerId({ channelId: filtered.channelId, ...(filtered.threadTs ? { threadTs: filtered.threadTs } : {}) });
+        const parts = [];
+        if (filtered.textRaw.trim()) {
+            parts.push({ type: "text", text: filtered.textRaw.trim() });
+        }
+        for (const file of filtered.files) {
+            parts.push(await downloadSlackFile(peerId, file));
+        }
+        if (parts.length === 0)
+            return;
+        const text = parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n")
+            .trim();
         try {
             await onMessage({
                 channel: "slack",
                 identityId: identity.id,
                 peerId,
-                text: filtered.textRaw.trim(),
+                text,
+                parts,
                 raw: event,
             });
         }
@@ -106,19 +226,30 @@ export function createSlackAdapter(identity, config, logger, onMessage, deps = {
         const filtered = shouldIgnore(event);
         if (filtered.ok)
             return;
-        const threadTs = typeof event.thread_ts === "string" ? event.thread_ts : null;
-        const ts = typeof event.ts === "string" ? event.ts : null;
-        const rootThread = threadTs || ts;
+        const rootThread = filtered.threadTs || filtered.ts;
         const peerId = formatSlackPeerId({ channelId: filtered.channelId, ...(rootThread ? { threadTs: rootThread } : {}) });
         const text = stripSlackMention(filtered.textRaw, botUserId);
-        if (!text)
+        const parts = [];
+        if (text) {
+            parts.push({ type: "text", text });
+        }
+        for (const file of filtered.files) {
+            parts.push(await downloadSlackFile(peerId, file));
+        }
+        if (parts.length === 0)
             return;
+        const promptText = parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n")
+            .trim();
         try {
             await onMessage({
                 channel: "slack",
                 identityId: identity.id,
                 peerId,
-                text,
+                text: promptText,
+                parts,
                 raw: event,
             });
         }
@@ -126,6 +257,57 @@ export function createSlackAdapter(identity, config, logger, onMessage, deps = {
             log.error({ error, peerId }, "slack inbound handler failed");
         }
     });
+    const sendMessageInternal = async (peerId, message) => {
+        const peer = parseSlackPeerId(peerId);
+        if (!peer.channelId) {
+            const error = new Error("Invalid Slack peerId");
+            error.status = 400;
+            throw error;
+        }
+        const partResults = [];
+        let sentParts = 0;
+        for (let index = 0; index < message.parts.length; index += 1) {
+            const part = message.parts[index];
+            try {
+                if (part.type === "text") {
+                    await withDeliveryRetry("slack.postMessage", () => web.chat.postMessage({
+                        channel: peer.channelId,
+                        text: part.text,
+                        ...(peer.threadTs ? { thread_ts: peer.threadTs } : {}),
+                    }), { logger: log });
+                }
+                else {
+                    const fileData = await readFile(part.filePath);
+                    const filename = part.filename || basename(part.filePath);
+                    await withDeliveryRetry("slack.uploadFile", () => web.files.uploadV2({
+                        channel_id: peer.channelId,
+                        file: fileData,
+                        filename,
+                        ...(peer.threadTs ? { thread_ts: peer.threadTs } : {}),
+                        ...(part.caption?.trim() ? { initial_comment: part.caption.trim() } : {}),
+                    }), { logger: log });
+                }
+                sentParts += 1;
+                partResults.push({ index, type: part.type, sent: true });
+            }
+            catch (error) {
+                const classified = classifyDeliveryError(error);
+                partResults.push({
+                    index,
+                    type: part.type,
+                    sent: false,
+                    error: classified.message,
+                    code: classified.code,
+                    retryable: classified.retryable,
+                });
+            }
+        }
+        return {
+            attemptedParts: message.parts.length,
+            sentParts,
+            partResults,
+        };
+    };
     return {
         name: "slack",
         identityId: identity.id,
@@ -153,17 +335,17 @@ export function createSlackAdapter(identity, config, logger, onMessage, deps = {
             }
             log.info("slack adapter stopped");
         },
+        async sendMessage(peerId, message) {
+            return sendMessageInternal(peerId, message);
+        },
         async sendText(peerId, text) {
-            const peer = parseSlackPeerId(peerId);
-            if (!peer.channelId)
-                throw new Error("Invalid Slack peerId");
-            const payload = {
-                channel: peer.channelId,
-                text,
-            };
-            if (peer.threadTs)
-                payload.thread_ts = peer.threadTs;
-            await web.chat.postMessage(payload);
+            const result = await sendMessageInternal(peerId, {
+                parts: [{ type: "text", text }],
+            });
+            if (result.sentParts === 0) {
+                const firstError = result.partResults.find((part) => !part.sent)?.error;
+                throw new Error(firstError || "Failed to deliver Slack text message");
+            }
         },
     };
 }