@hywkp/sider 0.0.3

package/dist/src/channel.js

@@ -0,0 +1,1201 @@
+import { DEFAULT_ACCOUNT_ID, createReplyPrefixOptions, createTypingCallbacks, formatTextWithAttachmentLinks, normalizeAccountId, resolveOutboundMediaUrls, } from "openclaw/plugin-sdk";
+const CHANNEL_ID = "sider";
+const DEFAULT_GATEWAY_URL = "http://47.82.167.142:3001";
+const DEFAULT_CONNECT_TIMEOUT_MS = 8_000;
+const DEFAULT_SEND_TIMEOUT_MS = 12_000;
+const DEFAULT_RECONNECT_DELAY_MS = 2_000;
+const IMAGE_EXTENSIONS = new Set([
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".gif",
+    ".webp",
+    ".bmp",
+    ".svg",
+    ".heic",
+    ".heif",
+    ".avif",
+]);
+const MIME_BY_EXTENSION = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".zip": "application/zip",
+};
+const meta = {
+    id: CHANNEL_ID,
+    label: "Sider",
+    selectionLabel: "Sider (siderclaw-gateway)",
+    docsPath: "/channels/sider",
+    docsLabel: "sider",
+    blurb: "Bridge OpenClaw with siderclaw-gateway via relay websocket.",
+    aliases: ["siderclaw"],
+    order: 97,
+};
+let runtimeRef = null;
+export function setSiderRuntime(runtime) {
+    runtimeRef = runtime;
+}
+function getSiderRuntime() {
+    if (!runtimeRef) {
+        throw new Error("sider runtime not initialized");
+    }
+    return runtimeRef;
+}
+function logDebug(message, data) {
+    const core = getSiderRuntime();
+    if (!core.logging.shouldLogVerbose()) {
+        return;
+    }
+    core.logging.getChildLogger({ channel: CHANNEL_ID }).debug?.(message, data);
+}
+function logInfo(message, data) {
+    getSiderRuntime().logging.getChildLogger({ channel: CHANNEL_ID }).info(message, data);
+}
+function logWarn(message, data) {
+    getSiderRuntime().logging.getChildLogger({ channel: CHANNEL_ID }).warn(message, data);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function normalizeGatewayUrl(raw) {
+    const fallback = DEFAULT_GATEWAY_URL;
+    const trimmed = raw?.trim() || fallback;
+    return trimmed.replace(/\/+$/, "");
+}
+function normalizeTimeout(raw, fallback) {
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) {
+        return fallback;
+    }
+    return Math.floor(raw);
+}
+function getSiderConfig(cfg) {
+    return (cfg.channels?.[CHANNEL_ID] ?? {});
+}
+function resolveSiderAccount(cfg, accountId) {
+    const id = normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID;
+    const channelCfg = getSiderConfig(cfg);
+    const accountCfg = id === DEFAULT_ACCOUNT_ID ? channelCfg : (channelCfg.accounts?.[id] ?? {});
+    const gatewayUrl = normalizeGatewayUrl(accountCfg.gatewayUrl);
+    const sessionId = accountCfg.sessionId?.trim() || accountCfg.sessionKey?.trim() || undefined;
+    const relayId = accountCfg.relayId?.trim() || `openclaw-${id}`;
+    const defaultTo = accountCfg.defaultTo?.trim() || (sessionId ? `session:${sessionId}` : undefined);
+    return {
+        accountId: id,
+        name: accountCfg.name?.trim() || id,
+        enabled: accountCfg.enabled !== false,
+        gatewayUrl,
+        sessionId,
+        relayId,
+        relayToken: accountCfg.relayToken?.trim() || undefined,
+        defaultTo,
+        connectTimeoutMs: normalizeTimeout(accountCfg.connectTimeoutMs, DEFAULT_CONNECT_TIMEOUT_MS),
+        sendTimeoutMs: normalizeTimeout(accountCfg.sendTimeoutMs, DEFAULT_SEND_TIMEOUT_MS),
+        reconnectDelayMs: normalizeTimeout(accountCfg.reconnectDelayMs, DEFAULT_RECONNECT_DELAY_MS),
+        configured: Boolean(gatewayUrl && sessionId && relayId),
+        config: accountCfg,
+    };
+}
+function listSiderAccountIds(cfg) {
+    const channelCfg = getSiderConfig(cfg);
+    const ids = new Set();
+    if (channelCfg.enabled !== undefined ||
+        channelCfg.gatewayUrl ||
+        channelCfg.sessionId ||
+        channelCfg.sessionKey ||
+        channelCfg.relayId) {
+        ids.add(DEFAULT_ACCOUNT_ID);
+    }
+    for (const id of Object.keys(channelCfg.accounts ?? {})) {
+        ids.add(id);
+    }
+    return ids.size > 0 ? Array.from(ids) : [DEFAULT_ACCOUNT_ID];
+}
+function parseSessionTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("Missing sider session target");
+    }
+    if (trimmed.startsWith("session:")) {
+        const sessionId = trimmed.slice("session:".length).trim();
+        if (!sessionId) {
+            throw new Error("Invalid sider target, empty session id");
+        }
+        return sessionId;
+    }
+    return trimmed;
+}
+function resolveOutboundSessionId(params) {
+    const target = params.to?.trim() || params.account.defaultTo?.trim() || "";
+    if (!target) {
+        throw new Error(`sider account "${params.account.accountId}" missing target; set 'to' or channels.${CHANNEL_ID}.defaultTo`);
+    }
+    return parseSessionTarget(target);
+}
+function resolveRelayWsUrl(gatewayUrl) {
+    const url = new URL(gatewayUrl);
+    if (url.pathname === "" || url.pathname === "/") {
+        url.pathname = "/ws/relay";
+    }
+    else if (!url.pathname.endsWith("/ws/relay")) {
+        url.pathname = `${url.pathname.replace(/\/+$/, "")}/ws/relay`;
+    }
+    if (url.protocol === "http:") {
+        url.protocol = "ws:";
+    }
+    else if (url.protocol === "https:") {
+        url.protocol = "wss:";
+    }
+    else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+        throw new Error(`Unsupported gateway URL protocol: ${url.protocol}`);
+    }
+    return url.toString();
+}
+async function wsDataToText(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return new TextDecoder().decode(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new TextDecoder().decode(data);
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) {
+        return await data.text();
+    }
+    return String(data ?? "");
+}
+function parseInboundFrame(rawText) {
+    try {
+        const parsed = JSON.parse(rawText);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        if (typeof parsed.type !== "string" || !parsed.type.trim()) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isRealtimeMessageFrame(frame) {
+    return frame.type === "message";
+}
+function isRealtimeEventFrame(frame) {
+    return frame.type === "event";
+}
+async function waitForSocketOpen(params) {
+    const { ws, timeoutMs, accountId } = params;
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error(`[${accountId}] websocket open timeout (${timeoutMs}ms)`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            ws.removeEventListener("open", onOpen);
+            ws.removeEventListener("close", onClose);
+            ws.removeEventListener("error", onError);
+        };
+        const onOpen = () => {
+            cleanup();
+            resolve();
+        };
+        const onClose = () => {
+            cleanup();
+            reject(new Error(`[${accountId}] websocket closed before open`));
+        };
+        const onError = () => {
+            cleanup();
+            reject(new Error(`[${accountId}] websocket failed before open`));
+        };
+        ws.addEventListener("open", onOpen);
+        ws.addEventListener("close", onClose);
+        ws.addEventListener("error", onError);
+    });
+}
+function closeSocketQuietly(ws) {
+    try {
+        ws.close();
+    }
+    catch {
+        // no-op
+    }
+}
+async function connectRelaySocket(params) {
+    const wsUrl = resolveRelayWsUrl(params.account.gatewayUrl);
+    logDebug("opening sider relay websocket", {
+        accountId: params.account.accountId,
+        wsUrl,
+        sessionId: params.sessionId,
+        relayId: params.relayId,
+    });
+    const ws = new WebSocket(wsUrl);
+    await waitForSocketOpen({
+        ws,
+        timeoutMs: params.account.connectTimeoutMs,
+        accountId: params.account.accountId,
+    });
+    const registerPayload = {
+        type: "register",
+        session_id: params.sessionId,
+        relay_id: params.relayId,
+    };
+    if (params.account.relayToken) {
+        registerPayload.token = params.account.relayToken;
+    }
+    ws.send(JSON.stringify(registerPayload));
+    return ws;
+}
+async function waitForAck(params) {
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error(`[${params.accountId}] timeout waiting sider ack`));
+        }, params.timeoutMs);
+        const cleanup = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            params.ws.removeEventListener("message", onMessage);
+            params.ws.removeEventListener("close", onClose);
+            params.ws.removeEventListener("error", onError);
+        };
+        const rejectWith = (err) => {
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const onMessage = (event) => {
+            void (async () => {
+                const text = await wsDataToText(event.data);
+                const frame = parseInboundFrame(text);
+                if (!frame) {
+                    return;
+                }
+                if (frame.type === "ping") {
+                    params.ws.send(JSON.stringify({ type: "pong" }));
+                    return;
+                }
+                if (frame.type === "replaced") {
+                    rejectWith(new Error(`[${params.accountId}] relay replaced while waiting ack`));
+                    return;
+                }
+                if (frame.type !== "ack") {
+                    return;
+                }
+                const ackSession = typeof frame.session_id === "string" ? frame.session_id : "";
+                const ackId = typeof frame.id === "string" ? frame.id.trim() : "";
+                if (ackSession === params.sessionId && ackId) {
+                    cleanup();
+                    resolve(ackId);
+                }
+            })().catch((err) => {
+                rejectWith(err);
+            });
+        };
+        const onClose = () => {
+            rejectWith(new Error(`[${params.accountId}] websocket closed before ack`));
+        };
+        const onError = () => {
+            rejectWith(new Error(`[${params.accountId}] websocket error before ack`));
+        };
+        params.ws.addEventListener("message", onMessage);
+        params.ws.addEventListener("close", onClose);
+        params.ws.addEventListener("error", onError);
+    });
+}
+async function sendMessageToSider(params) {
+    if (params.parts.length === 0) {
+        throw new Error("Cannot send sider message with empty parts");
+    }
+    const relayId = `${params.account.relayId}-tx-${crypto.randomUUID().slice(0, 8)}`;
+    const clientReqId = crypto.randomUUID();
+    const ws = await connectRelaySocket({
+        account: params.account,
+        sessionId: params.sessionId,
+        relayId,
+    });
+    try {
+        ws.send(JSON.stringify({
+            type: "message",
+            session_id: params.sessionId,
+            client_req_id: clientReqId,
+            parts: params.parts,
+        }));
+        const messageId = await waitForAck({
+            ws,
+            sessionId: params.sessionId,
+            timeoutMs: params.account.sendTimeoutMs,
+            accountId: params.account.accountId,
+        });
+        logDebug("sider outbound ack", {
+            accountId: params.account.accountId,
+            sessionId: params.sessionId,
+            clientReqId,
+            messageId,
+        });
+        return { messageId, conversationId: params.sessionId };
+    }
+    finally {
+        closeSocketQuietly(ws);
+    }
+}
+async function sendEventToSider(params) {
+    const relayId = `${params.account.relayId}-tx-${crypto.randomUUID().slice(0, 8)}`;
+    const clientReqId = crypto.randomUUID();
+    const ws = await connectRelaySocket({
+        account: params.account,
+        sessionId: params.sessionId,
+        relayId,
+    });
+    try {
+        ws.send(JSON.stringify({
+            type: "event",
+            session_id: params.sessionId,
+            client_req_id: clientReqId,
+            event_type: params.eventType,
+            payload: params.payload,
+            meta: params.meta ?? {},
+        }));
+        const eventId = await waitForAck({
+            ws,
+            sessionId: params.sessionId,
+            timeoutMs: params.account.sendTimeoutMs,
+            accountId: params.account.accountId,
+        });
+        logDebug("sider outbound event ack", {
+            accountId: params.account.accountId,
+            sessionId: params.sessionId,
+            eventType: params.eventType,
+            clientReqId,
+            eventId,
+        });
+        return { eventId, conversationId: params.sessionId };
+    }
+    finally {
+        closeSocketQuietly(ws);
+    }
+}
+async function sendSiderEventBestEffort(params) {
+    try {
+        await sendEventToSider({
+            account: params.account,
+            sessionId: params.sessionId,
+            eventType: params.event.eventType,
+            payload: params.event.payload,
+            meta: params.event.meta,
+        });
+    }
+    catch (err) {
+        logWarn("sider outbound event failed", {
+            accountId: params.account.accountId,
+            sessionId: params.sessionId,
+            eventType: params.event.eventType,
+            context: params.context,
+            error: String(err),
+        });
+    }
+}
+function extFromMediaUrl(raw) {
+    try {
+        if (/^https?:\/\//i.test(raw)) {
+            const pathname = new URL(raw).pathname;
+            return pathname.includes(".") ? pathname.slice(pathname.lastIndexOf(".")).toLowerCase() : "";
+        }
+    }
+    catch {
+        // no-op
+    }
+    const qPos = raw.indexOf("?");
+    const sanitized = qPos >= 0 ? raw.slice(0, qPos) : raw;
+    const slashPos = sanitized.lastIndexOf("/");
+    const last = slashPos >= 0 ? sanitized.slice(slashPos + 1) : sanitized;
+    const dotPos = last.lastIndexOf(".");
+    return dotPos >= 0 ? last.slice(dotPos).toLowerCase() : "";
+}
+function fileNameFromMediaUrl(raw) {
+    try {
+        if (/^https?:\/\//i.test(raw)) {
+            const pathname = new URL(raw).pathname;
+            const seg = pathname.split("/").filter(Boolean).pop();
+            return seg || undefined;
+        }
+    }
+    catch {
+        // no-op
+    }
+    const qPos = raw.indexOf("?");
+    const sanitized = qPos >= 0 ? raw.slice(0, qPos) : raw;
+    const seg = sanitized.split("/").filter(Boolean).pop();
+    return seg || undefined;
+}
+function inferMediaKind(mediaUrl) {
+    const ext = extFromMediaUrl(mediaUrl);
+    return IMAGE_EXTENSIONS.has(ext) ? "image" : "file";
+}
+function inferMediaMimeType(mediaUrl) {
+    const ext = extFromMediaUrl(mediaUrl);
+    return MIME_BY_EXTENSION[ext];
+}
+async function uploadMediaToSider(params) {
+    const mediaKind = inferMediaKind(params.mediaUrl);
+    const fileName = fileNameFromMediaUrl(params.mediaUrl);
+    const mimeType = inferMediaMimeType(params.mediaUrl);
+    // TODO(siderclaw-upload): Upload local/remote media to sider server and return hosted resource URL.
+    // Current placeholder returns the original mediaUrl directly.
+    const resourceUrl = params.mediaUrl;
+    void params.account;
+    return {
+        resourceUrl,
+        mediaKind,
+        mimeType,
+        fileName,
+    };
+}
+async function buildSiderPartsFromReplyPayload(params) {
+    const parts = [];
+    const text = params.payload.text?.trim();
+    if (text) {
+        parts.push({
+            type: "core.text",
+            spec_version: 1,
+            payload: { text },
+        });
+    }
+    const mediaUrls = resolveOutboundMediaUrls(params.payload);
+    for (const mediaUrl of mediaUrls) {
+        const uploaded = await uploadMediaToSider({
+            account: params.account,
+            mediaUrl,
+        });
+        parts.push({
+            type: "core.media",
+            spec_version: 1,
+            payload: {
+                media_type: uploaded.mediaKind,
+                url: uploaded.resourceUrl,
+                mime_type: uploaded.mimeType,
+                file_name: uploaded.fileName,
+            },
+            meta: {
+                source_media_url: mediaUrl,
+            },
+        });
+    }
+    return parts;
+}
+function parseTextFromPart(part) {
+    if (part.type !== "core.text") {
+        return null;
+    }
+    const payload = toRecord(part.payload);
+    if (payload?.text && typeof payload.text === "string") {
+        const text = payload.text.trim();
+        return text || null;
+    }
+    if (typeof part.payload === "string") {
+        const text = part.payload.trim();
+        return text || null;
+    }
+    return null;
+}
+function parseMediaFromPart(part) {
+    if (part.type !== "core.media") {
+        return null;
+    }
+    const payload = toRecord(part.payload);
+    if (!payload) {
+        return null;
+    }
+    const urlCandidates = [payload.url, payload.resource_url, payload.media_url];
+    const url = urlCandidates.find((entry) => typeof entry === "string" && entry.trim());
+    if (!url) {
+        return null;
+    }
+    const mimeCandidates = [payload.mime_type, payload.content_type];
+    const mimeType = mimeCandidates.find((entry) => typeof entry === "string" && entry.trim());
+    return { url: url.trim(), mimeType: mimeType?.trim() || undefined };
+}
+function buildEventMeta(params) {
+    return {
+        channel: CHANNEL_ID,
+        account_id: params.accountId,
+        schema_version: 1,
+    };
+}
+function buildTypingEvent(params) {
+    return {
+        eventType: "typing",
+        payload: {
+            on: params.state === "typing",
+            state: params.state,
+            session_id: params.sessionId,
+            ts: Date.now(),
+        },
+        meta: buildEventMeta({ accountId: params.accountId }),
+    };
+}
+function buildStreamingStartEvent(params) {
+    return {
+        eventType: "stream.start",
+        payload: {
+            session_id: params.sessionId,
+            stream_id: params.streamId,
+            ts: Date.now(),
+        },
+        meta: buildEventMeta({ accountId: params.accountId }),
+    };
+}
+function buildStreamingDeltaEvent(params) {
+    return {
+        eventType: "stream.delta",
+        payload: {
+            session_id: params.sessionId,
+            stream_id: params.streamId,
+            seq: params.seq,
+            delta: params.delta,
+            done: false,
+            chunk_chars: params.delta.length,
+            ts: Date.now(),
+        },
+        meta: buildEventMeta({ accountId: params.accountId }),
+    };
+}
+function buildStreamingDoneEvent(params) {
+    return {
+        eventType: "stream.done",
+        payload: {
+            session_id: params.sessionId,
+            stream_id: params.streamId,
+            seq: params.seq,
+            done: true,
+            reason: params.reason,
+            ts: Date.now(),
+        },
+        meta: buildEventMeta({ accountId: params.accountId }),
+    };
+}
+async function deliverReplyPayloadToSider(params) {
+    if (params.kind === "block") {
+        const delta = typeof params.payload.text === "string" ? params.payload.text : "";
+        if (delta.length === 0) {
+            return;
+        }
+        if (!params.streamState.active || !params.streamState.streamId) {
+            params.streamState.active = true;
+            params.streamState.streamId = crypto.randomUUID();
+            params.streamState.seq = 0;
+            const streamStartEvent = buildStreamingStartEvent({
+                sessionId: params.sessionId,
+                streamId: params.streamState.streamId,
+                accountId: params.account.accountId,
+            });
+            await sendSiderEventBestEffort({
+                account: params.account,
+                sessionId: params.sessionId,
+                event: streamStartEvent,
+                context: "stream.start",
+            });
+        }
+        params.streamState.seq += 1;
+        const streamDeltaEvent = buildStreamingDeltaEvent({
+            sessionId: params.sessionId,
+            streamId: params.streamState.streamId,
+            seq: params.streamState.seq,
+            delta,
+            accountId: params.account.accountId,
+        });
+        logDebug("sending stream delta event", {
+            accountId: params.account.accountId,
+            sessionId: params.sessionId,
+            eventType: streamDeltaEvent.eventType,
+            streamId: params.streamState.streamId,
+            seq: params.streamState.seq,
+            deltaLength: delta.length,
+        });
+        await sendSiderEventBestEffort({
+            account: params.account,
+            sessionId: params.sessionId,
+            event: streamDeltaEvent,
+            context: "stream.delta",
+        });
+        return;
+    }
+    if (params.streamState.active && params.streamState.streamId) {
+        params.streamState.seq += 1;
+        const streamDoneEvent = buildStreamingDoneEvent({
+            sessionId: params.sessionId,
+            streamId: params.streamState.streamId,
+            seq: params.streamState.seq,
+            accountId: params.account.accountId,
+            reason: "final",
+        });
+        await sendSiderEventBestEffort({
+            account: params.account,
+            sessionId: params.sessionId,
+            event: streamDoneEvent,
+            context: "stream.done",
+        });
+        params.streamState.active = false;
+        params.streamState.streamId = undefined;
+        params.streamState.seq = 0;
+    }
+    const parts = await buildSiderPartsFromReplyPayload({
+        account: params.account,
+        payload: params.payload,
+    });
+    if (parts.length === 0) {
+        return;
+    }
+    await sendMessageToSider({
+        account: params.account,
+        sessionId: params.sessionId,
+        parts,
+    });
+}
+async function handleInboundRealtimeMessage(params) {
+    const { cfg, account, event } = params;
+    const core = getSiderRuntime();
+    const sessionId = typeof event.session_id === "string" ? event.session_id.trim() : "";
+    if (!sessionId) {
+        return;
+    }
+    if ((event.source_role ?? "").toLowerCase() === "relay") {
+        return;
+    }
+    const parts = Array.isArray(event.parts) ? event.parts : [];
+    const textChunks = [];
+    const mediaItems = [];
+    for (const part of parts) {
+        const text = parseTextFromPart(part);
+        if (text) {
+            textChunks.push(text);
+            continue;
+        }
+        const media = parseMediaFromPart(part);
+        if (media) {
+            mediaItems.push(media);
+        }
+    }
+    const rawText = textChunks.join("\n").trim();
+    const mediaUrls = mediaItems.map((item) => item.url);
+    const mediaTypes = mediaItems
+        .map((item) => item.mimeType)
+        .filter((item) => Boolean(item));
+    const hasControlCommand = rawText ? core.channel.text.hasControlCommand(rawText, cfg) : false;
+    const shouldComputeCommandAuthorized = rawText
+        ? core.channel.commands.shouldComputeCommandAuthorized(rawText, cfg)
+        : false;
+    const commandAuthorized = shouldComputeCommandAuthorized
+        ? core.channel.commands.resolveCommandAuthorizedFromAuthorizers({
+            useAccessGroups: cfg.commands?.useAccessGroups !== false,
+            // Sider currently has no per-sender allowlist. Treat the authenticated relay session as trusted.
+            authorizers: [{ configured: true, allowed: true }],
+        })
+        : undefined;
+    if (!rawText && mediaUrls.length === 0) {
+        logDebug("drop inbound sider message: no text/media", {
+            accountId: account.accountId,
+            sessionId,
+            messageId: event.message_id,
+            partTypes: parts.map((part) => part.type),
+        });
+        return;
+    }
+    if (hasControlCommand) {
+        logInfo("sider control command inbound", {
+            accountId: account.accountId,
+            sessionId,
+            messageId: event.message_id,
+            commandAuthorized,
+        });
+        logDebug("detected sider control command", {
+            accountId: account.accountId,
+            sessionId,
+            messageId: event.message_id,
+            commandBody: rawText,
+            shouldComputeCommandAuthorized,
+            commandAuthorized,
+        });
+    }
+    const bodyForAgent = formatTextWithAttachmentLinks(rawText, mediaUrls);
+    const route = core.channel.routing.resolveAgentRoute({
+        cfg,
+        channel: CHANNEL_ID,
+        accountId: account.accountId,
+        peer: {
+            kind: "direct",
+            id: sessionId,
+        },
+    });
+    const to = `session:${sessionId}`;
+    const timestamp = typeof event.created_at === "number" && Number.isFinite(event.created_at)
+        ? event.created_at
+        : Date.now();
+    const envelopeBody = core.channel.reply.formatAgentEnvelope({
+        channel: "Sider",
+        from: sessionId,
+        timestamp,
+        envelope: core.channel.reply.resolveEnvelopeFormatOptions(cfg),
+        body: bodyForAgent,
+    });
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+        Body: envelopeBody,
+        BodyForAgent: bodyForAgent,
+        RawBody: bodyForAgent,
+        CommandBody: rawText,
+        BodyForCommands: rawText,
+        From: `${CHANNEL_ID}:client:${sessionId}`,
+        To: to,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "direct",
+        ConversationLabel: sessionId,
+        SenderId: "client",
+        SenderName: "client",
+        Provider: CHANNEL_ID,
+        Surface: CHANNEL_ID,
+        MessageSid: typeof event.message_id === "string" ? event.message_id : undefined,
+        Timestamp: timestamp,
+        WasMentioned: true,
+        OriginatingChannel: CHANNEL_ID,
+        OriginatingTo: to,
+        MediaUrl: mediaUrls[0],
+        MediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
+        MediaType: mediaTypes[0],
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+        CommandAuthorized: commandAuthorized,
+    });
+    const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
+        agentId: route.agentId,
+    });
+    await core.channel.session.recordInboundSession({
+        storePath,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        ctx: ctxPayload,
+        onRecordError: (err) => {
+            core.logging.getChildLogger({ channel: CHANNEL_ID }).warn("sider failed to record session", {
+                error: String(err),
+            });
+        },
+    });
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg,
+        agentId: route.agentId,
+        channel: CHANNEL_ID,
+        accountId: account.accountId,
+    });
+    logDebug("dispatching sider inbound message", {
+        accountId: account.accountId,
+        sessionId,
+        messageId: event.message_id,
+        routeSessionKey: route.sessionKey,
+        hasControlCommand,
+        commandAuthorized,
+        textLength: rawText.length,
+        mediaCount: mediaUrls.length,
+    });
+    const streamState = {
+        active: false,
+        streamId: undefined,
+        seq: 0,
+    };
+    const typingCallbacks = createTypingCallbacks({
+        start: async () => {
+            const typingEvent = buildTypingEvent({
+                state: "typing",
+                sessionId,
+                accountId: account.accountId,
+            });
+            logDebug("sending typing start event", {
+                accountId: account.accountId,
+                sessionId,
+                eventType: typingEvent.eventType,
+            });
+            await sendSiderEventBestEffort({
+                account,
+                sessionId,
+                event: typingEvent,
+                context: "typing.start",
+            });
+        },
+        stop: async () => {
+            const typingEvent = buildTypingEvent({
+                state: "idle",
+                sessionId,
+                accountId: account.accountId,
+            });
+            logDebug("sending typing stop event", {
+                accountId: account.accountId,
+                sessionId,
+                eventType: typingEvent.eventType,
+            });
+            await sendSiderEventBestEffort({
+                account,
+                sessionId,
+                event: typingEvent,
+                context: "typing.stop",
+            });
+        },
+        onStartError: (err) => {
+            logWarn("sider typing start failed", {
+                accountId: account.accountId,
+                sessionId,
+                error: String(err),
+            });
+        },
+        onStopError: (err) => {
+            logWarn("sider typing stop failed", {
+                accountId: account.accountId,
+                sessionId,
+                error: String(err),
+            });
+        },
+    });
+    try {
+        await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg,
+            dispatcherOptions: {
+                ...prefixOptions,
+                typingCallbacks,
+                deliver: async (payload, info) => {
+                    await deliverReplyPayloadToSider({
+                        account,
+                        sessionId,
+                        streamState,
+                        payload,
+                        kind: info.kind,
+                    });
+                },
+                onError: (err, info) => {
+                    core.logging
+                        .getChildLogger({ channel: CHANNEL_ID })
+                        .error(`sider ${info.kind} reply failed`, { error: String(err) });
+                },
+            },
+            replyOptions: {
+                onModelSelected,
+            },
+        });
+        logDebug("completed sider inbound dispatch", {
+            accountId: account.accountId,
+            sessionId,
+            messageId: event.message_id,
+        });
+    }
+    finally {
+        if (streamState.active && streamState.streamId) {
+            streamState.seq += 1;
+            const streamDoneEvent = buildStreamingDoneEvent({
+                sessionId,
+                streamId: streamState.streamId,
+                seq: streamState.seq,
+                accountId: account.accountId,
+                reason: "interrupted",
+            });
+            await sendSiderEventBestEffort({
+                account,
+                sessionId,
+                event: streamDoneEvent,
+                context: "stream.done.interrupted",
+            });
+            streamState.active = false;
+            streamState.streamId = undefined;
+            streamState.seq = 0;
+        }
+    }
+}
+async function handleInboundRealtimeEvent(params) {
+    const { account, event } = params;
+    const sessionId = typeof event.session_id === "string" ? event.session_id.trim() : "";
+    if (!sessionId) {
+        return;
+    }
+    if ((event.source_role ?? "").toLowerCase() === "relay") {
+        return;
+    }
+    logDebug("received sider realtime event", {
+        accountId: account.accountId,
+        sessionId,
+        eventId: event.event_id,
+        eventType: event.event_type,
+    });
+}
+async function monitorSiderSession(params) {
+    const { cfg, account, abortSignal, log } = params;
+    const sessionId = account.sessionId?.trim();
+    if (!sessionId) {
+        throw new Error(`sider account "${account.accountId}" missing sessionId`);
+    }
+    while (!abortSignal.aborted) {
+        let ws = null;
+        try {
+            ws = await connectRelaySocket({
+                account,
+                sessionId,
+                relayId: account.relayId,
+            });
+            log?.info(`[${account.accountId}] sider relay connected (${sessionId})`);
+            logInfo("sider relay connected", {
+                accountId: account.accountId,
+                sessionId,
+                relayId: account.relayId,
+            });
+            await new Promise((resolve) => {
+                const socket = ws;
+                if (!socket) {
+                    resolve();
+                    return;
+                }
+                const cleanup = () => {
+                    socket.removeEventListener("message", onMessage);
+                    socket.removeEventListener("close", onClose);
+                    socket.removeEventListener("error", onError);
+                    abortSignal.removeEventListener("abort", onAbort);
+                };
+                const onMessage = (event) => {
+                    void (async () => {
+                        const text = await wsDataToText(event.data);
+                        const frame = parseInboundFrame(text);
+                        if (!frame) {
+                            return;
+                        }
+                        if (frame.type === "ping") {
+                            socket.send(JSON.stringify({ type: "pong" }));
+                            return;
+                        }
+                        if (frame.type === "replaced") {
+                            log?.warn(`[${account.accountId}] sider relay replaced by a newer connection`);
+                            closeSocketQuietly(socket);
+                            return;
+                        }
+                        if (frame.type === "ack") {
+                            logDebug("received sider ack on monitor socket", {
+                                accountId: account.accountId,
+                                sessionId: frame.session_id,
+                                id: frame.id,
+                            });
+                            return;
+                        }
+                        if (isRealtimeEventFrame(frame)) {
+                            await handleInboundRealtimeEvent({
+                                account,
+                                event: frame,
+                            });
+                            return;
+                        }
+                        if (!isRealtimeMessageFrame(frame)) {
+                            return;
+                        }
+                        await handleInboundRealtimeMessage({
+                            cfg,
+                            account,
+                            event: frame,
+                        });
+                    })().catch((err) => {
+                        log?.error(`[${account.accountId}] sider inbound handling failed: ${String(err)}`);
+                    });
+                };
+                const onClose = () => {
+                    cleanup();
+                    resolve();
+                };
+                const onError = () => {
+                    cleanup();
+                    resolve();
+                };
+                const onAbort = () => {
+                    closeSocketQuietly(socket);
+                    cleanup();
+                    resolve();
+                };
+                socket.addEventListener("message", onMessage);
+                socket.addEventListener("close", onClose);
+                socket.addEventListener("error", onError);
+                abortSignal.addEventListener("abort", onAbort, { once: true });
+                if (abortSignal.aborted) {
+                    onAbort();
+                }
+            });
+        }
+        catch (err) {
+            log?.warn(`[${account.accountId}] sider relay loop error: ${String(err)}`);
+            logWarn("sider relay loop error", {
+                accountId: account.accountId,
+                error: String(err),
+            });
+        }
+        finally {
+            if (ws) {
+                closeSocketQuietly(ws);
+            }
+        }
+        if (!abortSignal.aborted) {
+            await sleep(account.reconnectDelayMs);
+        }
+    }
+}
+export const siderPlugin = {
+    id: CHANNEL_ID,
+    meta,
+    capabilities: {
+        chatTypes: ["direct"],
+        threads: false,
+        media: true,
+        blockStreaming: true,
+    },
+    streaming: {
+        blockStreamingCoalesceDefaults: { minChars: 1200, idleMs: 900 },
+    },
+    configSchema: {
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                enabled: { type: "boolean" },
+                name: { type: "string" },
+                gatewayUrl: { type: "string" },
+                sessionId: { type: "string" },
+                sessionKey: { type: "string" },
+                relayId: { type: "string" },
+                relayToken: { type: "string" },
+                defaultTo: { type: "string" },
+                connectTimeoutMs: { type: "number", minimum: 1 },
+                sendTimeoutMs: { type: "number", minimum: 1 },
+                reconnectDelayMs: { type: "number", minimum: 1 },
+                accounts: {
+                    type: "object",
+                    additionalProperties: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            enabled: { type: "boolean" },
+                            name: { type: "string" },
+                            gatewayUrl: { type: "string" },
+                            sessionId: { type: "string" },
+                            sessionKey: { type: "string" },
+                            relayId: { type: "string" },
+                            relayToken: { type: "string" },
+                            defaultTo: { type: "string" },
+                            connectTimeoutMs: { type: "number", minimum: 1 },
+                            sendTimeoutMs: { type: "number", minimum: 1 },
+                            reconnectDelayMs: { type: "number", minimum: 1 },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
+    config: {
+        listAccountIds: (cfg) => listSiderAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveSiderAccount(cfg, accountId),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            name: account.name,
+            baseUrl: account.gatewayUrl,
+            relayId: account.relayId,
+            sessionId: account.sessionId,
+            sessionKey: account.sessionId,
+        }),
+        resolveDefaultTo: ({ cfg, accountId }) => resolveSiderAccount(cfg, accountId).defaultTo,
+    },
+    outbound: {
+        deliveryMode: "direct",
+        sendText: async ({ cfg, accountId, to, text }) => {
+            const account = resolveSiderAccount(cfg, accountId);
+            if (!account.configured) {
+                throw new Error(`sider account "${account.accountId}" is not configured: missing gatewayUrl/sessionId(or sessionKey)/relayId`);
+            }
+            const sessionId = resolveOutboundSessionId({ account, to });
+            const payload = text?.trim();
+            if (!payload) {
+                throw new Error("sider sendText requires non-empty text");
+            }
+            const result = await sendMessageToSider({
+                account,
+                sessionId,
+                parts: [
+                    {
+                        type: "core.text",
+                        spec_version: 1,
+                        payload: { text: payload },
+                    },
+                ],
+            });
+            return {
+                channel: CHANNEL_ID,
+                messageId: result.messageId,
+                conversationId: result.conversationId,
+            };
+        },
+        sendMedia: async ({ cfg, accountId, to, text, mediaUrl }) => {
+            const account = resolveSiderAccount(cfg, accountId);
+            if (!account.configured) {
+                throw new Error(`sider account "${account.accountId}" is not configured: missing gatewayUrl/sessionId(or sessionKey)/relayId`);
+            }
+            const sessionId = resolveOutboundSessionId({ account, to });
+            const parts = await buildSiderPartsFromReplyPayload({
+                account,
+                payload: {
+                    text,
+                    mediaUrl,
+                },
+            });
+            if (parts.length === 0) {
+                throw new Error("sider sendMedia requires text and/or mediaUrl");
+            }
+            const result = await sendMessageToSider({
+                account,
+                sessionId,
+                parts,
+            });
+            return {
+                channel: CHANNEL_ID,
+                messageId: result.messageId,
+                conversationId: result.conversationId,
+            };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = resolveSiderAccount(ctx.cfg, ctx.accountId);
+            if (!account.configured) {
+                throw new Error(`sider account "${account.accountId}" is not configured: missing gatewayUrl/sessionId(or sessionKey)/relayId`);
+            }
+            ctx.log?.info(`[${account.accountId}] starting sider relay monitor (${account.gatewayUrl}, relayId=${account.relayId})`);
+            await monitorSiderSession({
+                cfg: ctx.cfg,
+                account,
+                abortSignal: ctx.abortSignal,
+                log: ctx.log,
+            });
+            ctx.log?.info(`[${account.accountId}] sider relay monitor stopped`);
+        },
+    },
+};
+//# sourceMappingURL=channel.js.map