@evgenyy/lessinbox-channel 0.1.6 → 0.1.9

package/dist/index.js

@@ -2,7 +2,9 @@ import Redis from "ioredis";
 import WebSocket from "ws";
 const DEFAULT_RECONNECT_MS = 1_500;
 const MIN_RECONNECT_MS = 250;
+const INBOUND_MESSAGE_DEDUPE_TTL_MS = 5 * 60 * 1000;
 const TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "canceled"]);
+const ACTIVE_RUN_STATUSES = new Set(["queued", "running", "waiting_for_human"]);
 function normalizeBaseUrl(baseUrl) {
     return baseUrl.replace(/\/+$/, "");
 }
@@ -91,10 +93,20 @@ function parseRunRef(value) {
     const threadId = toOptionalString(record.threadId);
     const runId = toOptionalString(record.runId);
     const status = toOptionalString(record.status);
-    if (!threadId || !runId) {
+    if (!threadId) {
         return undefined;
     }
-    return { threadId, runId, status };
+    return {
+        threadId,
+        ...(runId ? { runId } : {}),
+        ...(status ? { status } : {})
+    };
+}
+function isTerminalRunStatus(status) {
+    return Boolean(status && TERMINAL_RUN_STATUSES.has(status));
+}
+function isActiveRunStatus(status) {
+    return Boolean(status && ACTIVE_RUN_STATUSES.has(status));
 }
 function extractRunId(payload) {
     const record = asRecord(payload);
@@ -148,19 +160,19 @@ function buildWorkspaceWsEndpoint(apiUrl, wsUrlOverride) {
     url.search = "";
     const normalizedPath = url.pathname.replace(/\/+$/, "");
     if (!normalizedPath || normalizedPath === "/") {
-        url.pathname = "/v1/ws";
+        url.pathname = "/v2/ws";
         return url.toString();
     }
-    if (normalizedPath.endsWith("/v2")) {
+    if (normalizedPath.endsWith("/v1")) {
         const prefix = normalizedPath.slice(0, -3);
-        url.pathname = `${prefix || ""}/v1/ws`;
+        url.pathname = `${prefix || ""}/v2/ws`;
         return url.toString();
     }
-    if (normalizedPath.endsWith("/v1")) {
+    if (normalizedPath.endsWith("/v2")) {
         url.pathname = `${normalizedPath}/ws`;
         return url.toString();
     }
-    url.pathname = `${normalizedPath}/v1/ws`;
+    url.pathname = `${normalizedPath}/v2/ws`;
     return url.toString();
 }
 function buildWorkspaceWsUrl(apiUrl, token, wsUrlOverride) {
@@ -389,14 +401,40 @@ class WorkspaceStreamConsumer {
         }
         const payload = asRecord(event.payload);
         const toStatus = toOptionalString(payload?.to);
-        if (!toStatus || !TERMINAL_RUN_STATUSES.has(toStatus)) {
+        const mappedConversationId = await this.options.mappingStore.getConversationKeyForRun(event.runId);
+        const conversationId = event.conversationId ?? mappedConversationId ?? (event.threadId ? `thread:${event.threadId}` : undefined);
+        if (!conversationId) {
+            if (isTerminalRunStatus(toStatus)) {
+                await this.options.mappingStore.deleteRun(event.runId);
+            }
             return;
         }
-        const conversationId = event.conversationId ?? (await this.options.mappingStore.getConversationKeyForRun(event.runId));
-        if (conversationId) {
-            await this.options.mappingStore.deleteConversation(conversationId);
+        const existing = await this.options.mappingStore.getConversationRun(conversationId);
+        const threadId = event.threadId ?? existing?.threadId;
+        if (!threadId) {
+            if (isTerminalRunStatus(toStatus)) {
+                await this.options.mappingStore.deleteRun(event.runId);
+            }
+            return;
         }
-        await this.options.mappingStore.deleteRun(event.runId);
+        const resolvedStatus = toStatus ?? existing?.status;
+        if (isTerminalRunStatus(toStatus)) {
+            await this.options.mappingStore.setConversationRun(conversationId, {
+                threadId,
+                ...(resolvedStatus ? { status: resolvedStatus } : {})
+            });
+            await this.options.mappingStore.deleteRun(event.runId);
+            return;
+        }
+        if (existing?.runId && existing.runId !== event.runId) {
+            await this.options.mappingStore.deleteRun(existing.runId);
+        }
+        await this.options.mappingStore.setConversationRun(conversationId, {
+            threadId,
+            runId: event.runId,
+            ...(resolvedStatus ? { status: resolvedStatus } : {})
+        });
+        await this.options.mappingStore.setConversationKeyForRun(event.runId, conversationId);
     }
     async emit(event) {
         for (const listener of this.listeners) {
@@ -453,6 +491,10 @@ function ensureWorkspaceConsumer(accountId, account, api, mappingStore) {
     return consumer;
 }
 export async function shutdownLessinboxPluginResources() {
+    for (const unsubscribe of gatewayUnsubscribers.values()) {
+        unsubscribe();
+    }
+    gatewayUnsubscribers.clear();
     for (const consumer of workspaceConsumers.values()) {
         consumer.stop();
     }
@@ -461,6 +503,8 @@ export async function shutdownLessinboxPluginResources() {
         await store.close();
     }
     mappingStores.clear();
+    handledInboundMessages.clear();
+    lessinboxPluginRuntime = null;
 }
 export class LessinboxApi {
     constructor(config) {
@@ -524,6 +568,12 @@ export class LessinboxApi {
             idempotencyKey: randomIdempotencyKey()
         });
     }
+    async getRun(runId) {
+        return this.request(`/v2/runs/${runId}`, { method: "GET" });
+    }
+    async getThread(threadId) {
+        return this.request(`/v2/threads/${threadId}`, { method: "GET" });
+    }
     async listThreads(input = {}) {
         const params = new URLSearchParams();
         if (input.bucket)
@@ -538,11 +588,22 @@ export class LessinboxApi {
         return this.request(`/v2/threads${query ? `?${query}` : ""}`, { method: "GET" });
     }
     async createWorkspaceWsToken() {
-        return this.request("/v1/workspace/ws-token", {
+        return this.request("/v2/workspace/ws-token", {
             method: "POST",
             body: {}
         });
     }
+    async getThreadFeed(input) {
+        const params = new URLSearchParams();
+        if (typeof input.limit === "number") {
+            params.set("limit", String(input.limit));
+        }
+        if (input.cursor) {
+            params.set("cursor", input.cursor);
+        }
+        const query = params.toString();
+        return this.request(`/v2/threads/${input.threadId}/feed${query ? `?${query}` : ""}`, { method: "GET" });
+    }
     async request(path, options) {
         const headers = new Headers({
             Authorization: `Bearer ${this.apiKey}`,
@@ -598,6 +659,7 @@ export function resolveAccountConfig(config, accountId) {
     }
     const mappingStore = resolveMappingStoreKind(account.mappingStore);
     return {
+        accountId: resolvedId,
         enabled: typeof account.enabled === "boolean" ? account.enabled : true,
         apiUrl,
         apiKey,
@@ -609,6 +671,49 @@ export function resolveAccountConfig(config, accountId) {
         workspaceStream: resolveWorkspaceStreamConfig(account.workspaceStream)
     };
 }
+const gatewayUnsubscribers = new Map();
+const handledInboundMessages = new Map();
+let lessinboxPluginRuntime = null;
+function setLessinboxPluginRuntime(runtime) {
+    if (!runtime || typeof runtime !== "object") {
+        lessinboxPluginRuntime = null;
+        return;
+    }
+    lessinboxPluginRuntime = runtime;
+}
+function getLessinboxPluginRuntime() {
+    return lessinboxPluginRuntime;
+}
+function formatError(err) {
+    if (err instanceof Error && err.message) {
+        return err.message;
+    }
+    if (typeof err === "string") {
+        return err;
+    }
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function toOptionalTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    const asString = toOptionalString(value);
+    if (!asString) {
+        return undefined;
+    }
+    const parsed = Date.parse(asString);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function deriveConversationKey(input) {
     if (input.conversationId && input.conversationId.trim().length > 0) {
         return input.conversationId;
@@ -618,11 +723,197 @@ function deriveConversationKey(input) {
     }
     return null;
 }
+function listAccountIds(config) {
+    const accounts = readPath(config, ["channels", "lessinbox", "accounts"]);
+    if (!accounts || typeof accounts !== "object") {
+        return [];
+    }
+    return Object.keys(accounts);
+}
+function resolveSendTarget(input) {
+    const explicitTarget = toOptionalString(input.target) ??
+        toOptionalString(input.to) ??
+        toOptionalString(input.recipient) ??
+        toOptionalString(input.metadata?.target);
+    if (!explicitTarget) {
+        return {};
+    }
+    const separatorIndex = explicitTarget.indexOf(":");
+    if (separatorIndex > 0 && separatorIndex < explicitTarget.length - 1) {
+        const kind = explicitTarget.slice(0, separatorIndex).toLowerCase();
+        const value = explicitTarget.slice(separatorIndex + 1).trim();
+        if (!value) {
+            return {};
+        }
+        if (kind === "thread") {
+            return { threadId: value, conversationId: `thread:${value}` };
+        }
+        if (kind === "channel") {
+            return { channelId: value, conversationId: `channel:${value}` };
+        }
+        if (kind === "account") {
+            return { accountId: value };
+        }
+        if (kind === "run" || kind === "session") {
+            return { runId: value };
+        }
+        if (kind === "conversation") {
+            return { conversationId: value };
+        }
+    }
+    if (/^thr_[a-zA-Z0-9]+$/.test(explicitTarget)) {
+        return { threadId: explicitTarget, conversationId: `thread:${explicitTarget}` };
+    }
+    if (/^chn_[a-zA-Z0-9]+$/.test(explicitTarget)) {
+        return { channelId: explicitTarget, conversationId: `channel:${explicitTarget}` };
+    }
+    const accountIds = input.config ? listAccountIds(input.config) : [];
+    if (accountIds.includes(explicitTarget)) {
+        return { accountId: explicitTarget };
+    }
+    // Raw IDs default to channel target so CLI `--target <channelId>` works out of the box.
+    return { channelId: explicitTarget, conversationId: `channel:${explicitTarget}` };
+}
+function deriveChannelIdFromConversationKey(conversationKey) {
+    if (!conversationKey || !conversationKey.startsWith("channel:")) {
+        return undefined;
+    }
+    const channelId = conversationKey.slice("channel:".length).trim();
+    return channelId.length > 0 ? channelId : undefined;
+}
+function deriveTitle(input) {
+    if (input.title && input.title.trim().length > 0) {
+        return input.title.trim();
+    }
+    return input.text.slice(0, 80);
+}
+function toRunRefFromThreadSummary(summary) {
+    const runId = toOptionalString(summary.session_id) ?? toOptionalString(summary.run_id);
+    const status = toOptionalString(summary.session_status) ?? toOptionalString(summary.run_status);
+    return {
+        threadId: summary.id,
+        ...(runId ? { runId } : {}),
+        ...(status ? { status } : {})
+    };
+}
+function toRunRefFromThreadDetail(thread) {
+    const session = asRecord(thread.session);
+    const run = asRecord(thread.run);
+    const runId = toOptionalString(session?.id) ?? toOptionalString(run?.id);
+    const status = toOptionalString(session?.status) ?? toOptionalString(run?.status);
+    return {
+        threadId: thread.id,
+        ...(runId ? { runId } : {}),
+        ...(status ? { status } : {})
+    };
+}
+function normalizeConversationMetadata(metadata, conversationKey) {
+    if (!conversationKey) {
+        return metadata;
+    }
+    return {
+        ...(metadata ?? {}),
+        conversation_id: conversationKey
+    };
+}
+function purgeHandledInboundMessages(now) {
+    for (const [key, expiresAt] of handledInboundMessages.entries()) {
+        if (expiresAt <= now) {
+            handledInboundMessages.delete(key);
+        }
+    }
+}
+function hasHandledInboundMessage(key) {
+    const now = Date.now();
+    purgeHandledInboundMessages(now);
+    const expiresAt = handledInboundMessages.get(key);
+    return typeof expiresAt === "number" && expiresAt > now;
+}
+function markHandledInboundMessage(key) {
+    handledInboundMessages.set(key, Date.now() + INBOUND_MESSAGE_DEDUPE_TTL_MS);
+}
+function deriveHandledInboundKey(accountId, messageId) {
+    return `${accountId}:${messageId}`;
+}
+function resolveMessageActorType(message) {
+    const actor = asRecord(message?.actor);
+    return toOptionalString(actor?.type) ?? "unknown";
+}
+function resolveMessageActorUserId(message) {
+    const actor = asRecord(message?.actor);
+    return toOptionalString(actor?.user_id) ?? toOptionalString(actor?.userId);
+}
+function resolveEventPayloadMessage(event) {
+    const payload = asRecord(event.payload);
+    const message = asRecord(payload?.message);
+    const id = toOptionalString(message?.id);
+    if (!id) {
+        return undefined;
+    }
+    return {
+        id,
+        run_id: toOptionalString(message?.run_id) ?? undefined,
+        session_id: toOptionalString(message?.session_id) ?? undefined,
+        kind: toOptionalString(message?.kind),
+        text: toOptionalString(message?.text),
+        actor: asRecord(message?.actor),
+        created_at: toOptionalString(message?.created_at)
+    };
+}
+async function findFeedMessageById(api, threadId, messageId) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            const feed = await api.getThreadFeed({ threadId, limit: 50 });
+            const found = feed.entries.find((entry) => toOptionalString(entry?.message?.id) === messageId)?.message;
+            if (found) {
+                return found;
+            }
+        }
+        catch {
+            // ignore and retry
+        }
+        if (attempt < 2) {
+            await sleep((attempt + 1) * 120);
+        }
+    }
+    return undefined;
+}
+function coalesceInboundMessage(messageId, payloadMessage, feedMessage) {
+    const text = toOptionalString(feedMessage?.text) ??
+        toOptionalString(payloadMessage?.text);
+    if (!text) {
+        return null;
+    }
+    const actorType = resolveMessageActorType(feedMessage) !== "unknown"
+        ? resolveMessageActorType(feedMessage)
+        : resolveMessageActorType(payloadMessage);
+    const actorUserId = resolveMessageActorUserId(feedMessage) ??
+        resolveMessageActorUserId(payloadMessage);
+    const runId = toOptionalString(feedMessage?.run_id) ??
+        toOptionalString(feedMessage?.session_id) ??
+        toOptionalString(payloadMessage?.run_id) ??
+        toOptionalString(payloadMessage?.session_id);
+    const createdAtMs = toOptionalTimestamp(feedMessage?.created_at) ??
+        toOptionalTimestamp(payloadMessage?.created_at);
+    return {
+        id: messageId,
+        text,
+        actorType,
+        ...(actorUserId ? { actorUserId } : {}),
+        ...(runId ? { runId } : {}),
+        ...(typeof createdAtMs === "number" ? { createdAtMs } : {})
+    };
+}
 async function sendTextToLessinbox(input) {
     if (!input.config) {
         throw new Error("Plugin sendText did not receive runtime config");
     }
-    const accountRuntimeId = deriveAccountRuntimeId(input.accountId);
+    const resolvedTarget = resolveSendTarget(input);
+    const resolvedThreadId = input.threadId ?? resolvedTarget.threadId;
+    const resolvedRunId = input.runId ?? resolvedTarget.runId;
+    const resolvedChannelId = input.channelId ?? resolvedTarget.channelId;
+    const resolvedConversationId = input.conversationId ?? resolvedTarget.conversationId;
+    const accountRuntimeId = deriveAccountRuntimeId(input.accountId ?? resolvedTarget.accountId);
     const account = resolveAccountConfig(input.config, accountRuntimeId);
     if (account.enabled === false) {
         throw new Error("Lessinbox account is disabled");
@@ -630,40 +921,376 @@ async function sendTextToLessinbox(input) {
     const api = new LessinboxApi(account);
     const mappingStore = getConversationMappingStore(accountRuntimeId, account);
     ensureWorkspaceConsumer(accountRuntimeId, account, api, mappingStore);
-    const conversationKey = deriveConversationKey(input);
+    const conversationKey = deriveConversationKey({
+        ...input,
+        threadId: resolvedThreadId,
+        conversationId: resolvedConversationId
+    });
     const mappedRun = conversationKey ? await mappingStore.getConversationRun(conversationKey) : undefined;
-    let threadId = input.threadId ?? mappedRun?.threadId;
-    let runId = input.runId ?? mappedRun?.runId;
-    if (!threadId || !runId) {
-        const title = (input.title && input.title.trim().length > 0 ? input.title.trim() : null) ??
-            input.text.slice(0, 80);
+    let threadId = resolvedThreadId ?? mappedRun?.threadId;
+    let runId = resolvedRunId ?? mappedRun?.runId;
+    let runStatus = mappedRun?.status;
+    let channelId = resolvedChannelId ?? deriveChannelIdFromConversationKey(conversationKey);
+    // Recover latest known thread for channel-targeted conversations when in-memory mapping is empty.
+    if (!threadId && !runId && channelId) {
+        const listing = await api.listThreads({
+            bucket: "all",
+            channelId,
+            limit: 1
+        });
+        const latest = listing.threads[0];
+        if (latest) {
+            const recovered = toRunRefFromThreadSummary(latest);
+            threadId = recovered.threadId;
+            runId = recovered.runId;
+            runStatus = recovered.status;
+        }
+    }
+    // Thread details give us canonical channel and latest session snapshot.
+    if (threadId && (!channelId || !runId || !runStatus)) {
+        const thread = await api.getThread(threadId);
+        channelId = channelId ?? thread.channel_id;
+        const detailRef = toRunRefFromThreadDetail(thread);
+        if (!runId && detailRef.runId) {
+            runId = detailRef.runId;
+        }
+        if (!runStatus && detailRef.status) {
+            runStatus = detailRef.status;
+        }
+    }
+    // For mapped runs, verify status so terminal sessions rotate automatically.
+    if (runId && !resolvedRunId) {
+        try {
+            const runSnapshot = await api.getRun(runId);
+            const run = runSnapshot.run;
+            runStatus = toOptionalString(run.status) ?? runStatus;
+            if (!threadId) {
+                threadId = toOptionalString(run.thread_id) ?? threadId;
+            }
+            channelId = channelId ?? toOptionalString(run.channel_id);
+        }
+        catch {
+            runId = undefined;
+            runStatus = undefined;
+        }
+    }
+    if (runId && !resolvedRunId && !isActiveRunStatus(runStatus)) {
+        await mappingStore.deleteRun(runId);
+        runId = undefined;
+    }
+    if (!runId) {
         const started = await api.startRun({
-            title,
-            channelId: input.channelId ?? api.getDefaultChannelId(),
-            metadata: input.metadata
+            title: deriveTitle(input),
+            channelId: channelId ?? api.getDefaultChannelId(),
+            threadId,
+            metadata: normalizeConversationMetadata(input.metadata, conversationKey)
         });
         threadId = started.thread_id;
         runId = started.run_id;
+        runStatus = started.session_status ?? started.status;
+        channelId = channelId ?? api.getDefaultChannelId();
+    }
+    if (!threadId) {
+        throw new Error("Unable to resolve Lessinbox thread for outbound message");
     }
-    await api.postMessage({
+    const message = await api.postMessage({
         threadId,
         runId,
         text: input.text,
         kind: "text"
     });
+    const resolvedMessageRunId = message.run_id ?? runId;
     if (conversationKey) {
-        if (mappedRun?.runId && mappedRun.runId !== runId) {
+        if (mappedRun?.runId && mappedRun.runId !== resolvedMessageRunId) {
             await mappingStore.deleteRun(mappedRun.runId);
         }
-        await mappingStore.setConversationRun(conversationKey, { threadId, runId });
-        await mappingStore.setConversationKeyForRun(runId, conversationKey);
+        await mappingStore.setConversationRun(conversationKey, {
+            threadId,
+            ...(resolvedMessageRunId ? { runId: resolvedMessageRunId } : {}),
+            ...(runStatus ? { status: runStatus } : {})
+        });
+        if (resolvedMessageRunId) {
+            await mappingStore.setConversationKeyForRun(resolvedMessageRunId, conversationKey);
+        }
     }
     return {
         ok: true,
         threadId,
-        runId
+        runId: resolvedMessageRunId ?? runId
     };
 }
+async function sendMediaToLessinbox(input) {
+    const mediaUrl = toOptionalString(input.mediaUrl);
+    const caption = input.text?.trim() ?? "";
+    if (!mediaUrl) {
+        return sendTextToLessinbox({
+            ...input,
+            text: caption
+        });
+    }
+    const messageText = [caption, `Attachment: ${mediaUrl}`].filter(Boolean).join("\n\n");
+    return sendTextToLessinbox({
+        ...input,
+        text: messageText || `Attachment: ${mediaUrl}`
+    });
+}
+async function sendReplyPayloadToLessinbox(input) {
+    const mediaUrls = input.payload.mediaUrls?.length
+        ? input.payload.mediaUrls
+        : input.payload.mediaUrl
+            ? [input.payload.mediaUrl]
+            : [];
+    if (mediaUrls.length === 0) {
+        await sendTextToLessinbox({
+            text: input.payload.text ?? "",
+            accountId: input.accountId,
+            config: input.config,
+            threadId: input.threadId,
+            runId: input.runId,
+            conversationId: `thread:${input.threadId}`
+        });
+        return;
+    }
+    let first = true;
+    for (const mediaUrl of mediaUrls) {
+        await sendMediaToLessinbox({
+            text: first ? input.payload.text ?? "" : "",
+            mediaUrl,
+            accountId: input.accountId,
+            config: input.config,
+            threadId: input.threadId,
+            runId: input.runId,
+            conversationId: `thread:${input.threadId}`
+        });
+        first = false;
+    }
+}
+async function dispatchInboundMessageToRuntime(input) {
+    const routing = input.runtime.channel?.routing?.resolveAgentRoute;
+    const replyRuntime = input.runtime.channel?.reply;
+    if (!routing || !replyRuntime?.finalizeInboundContext || !replyRuntime.dispatchReplyWithBufferedBlockDispatcher) {
+        return;
+    }
+    const route = routing({
+        cfg: input.cfg,
+        channel: "lessinbox",
+        accountId: input.accountId,
+        peer: {
+            kind: "direct",
+            id: input.threadId
+        }
+    });
+    const routeSessionKey = toOptionalString(route.sessionKey) ??
+        toOptionalString(route.mainSessionKey) ??
+        `agent:main:lessinbox:thread:${input.threadId}`;
+    const routeAccountId = toOptionalString(route.accountId) ?? input.accountId;
+    const routeAgentId = toOptionalString(route.agentId);
+    const ctxPayload = replyRuntime.finalizeInboundContext({
+        Body: input.message.text,
+        BodyForAgent: input.message.text,
+        RawBody: input.message.text,
+        CommandBody: input.message.text,
+        From: `lessinbox:thread:${input.threadId}`,
+        To: `thread:${input.threadId}`,
+        SessionKey: routeSessionKey,
+        AccountId: routeAccountId,
+        ChatType: "direct",
+        ConversationLabel: `Lessinbox thread ${input.threadId}`,
+        SenderId: input.message.actorUserId ?? `thread:${input.threadId}`,
+        Provider: "lessinbox",
+        Surface: "lessinbox",
+        MessageSid: input.message.id,
+        Timestamp: input.message.createdAtMs ?? Date.now(),
+        OriginatingChannel: "lessinbox",
+        OriginatingTo: `thread:${input.threadId}`,
+        CommandAuthorized: true
+    });
+    const sessionStore = asRecord(input.cfg)?.session;
+    const resolveStorePath = input.runtime.channel?.session?.resolveStorePath;
+    const recordInboundSession = input.runtime.channel?.session?.recordInboundSession;
+    if (resolveStorePath && recordInboundSession) {
+        const storePath = resolveStorePath(asRecord(sessionStore)?.store, { agentId: routeAgentId });
+        await recordInboundSession({
+            storePath,
+            sessionKey: routeSessionKey,
+            ctx: ctxPayload,
+            onRecordError: (err) => {
+                input.log?.error?.(`lessinbox failed recording inbound session metadata: ${formatError(err)}`);
+            }
+        });
+    }
+    input.runtime.system?.enqueueSystemEvent?.(`Lessinbox message in thread ${input.threadId}: ${input.message.text.slice(0, 160)}`, {
+        sessionKey: routeSessionKey,
+        contextKey: `lessinbox:message:${input.threadId}:${input.message.id}`
+    });
+    await replyRuntime.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: input.cfg,
+        dispatcherOptions: {
+            deliver: async (payload) => {
+                await sendReplyPayloadToLessinbox({
+                    payload,
+                    accountId: input.accountId,
+                    config: input.cfg,
+                    threadId: input.threadId,
+                    runId: input.runId
+                });
+                input.runtime.channel?.activity?.record?.({
+                    channel: "lessinbox",
+                    accountId: input.accountId,
+                    direction: "outbound"
+                });
+            },
+            onError: (err, info) => {
+                input.log?.error?.(`lessinbox ${info.kind} reply failed: ${formatError(err)}`);
+            }
+        }
+    });
+}
+async function handleGatewayInboundEvent(input) {
+    if (input.event.kind !== "message.created") {
+        return;
+    }
+    const threadId = input.event.threadId;
+    if (!threadId) {
+        return;
+    }
+    const payloadMessage = resolveEventPayloadMessage(input.event);
+    const messageId = toOptionalString(payloadMessage?.id);
+    if (!messageId) {
+        return;
+    }
+    const handledKey = deriveHandledInboundKey(input.accountId, messageId);
+    if (hasHandledInboundMessage(handledKey)) {
+        return;
+    }
+    const feedMessage = await findFeedMessageById(input.api, threadId, messageId);
+    const inboundMessage = coalesceInboundMessage(messageId, payloadMessage, feedMessage);
+    if (!inboundMessage) {
+        return;
+    }
+    if (inboundMessage.actorType !== "user") {
+        return;
+    }
+    markHandledInboundMessage(handledKey);
+    const conversationId = input.event.conversationId ?? `thread:${threadId}`;
+    const runId = inboundMessage.runId ?? input.event.runId;
+    if (runId) {
+        await input.mappingStore.setConversationRun(conversationId, {
+            threadId,
+            runId,
+            status: "running"
+        });
+        await input.mappingStore.setConversationKeyForRun(runId, conversationId);
+    }
+    const at = inboundMessage.createdAtMs ?? Date.now();
+    input.runtime.channel?.activity?.record?.({
+        channel: "lessinbox",
+        accountId: input.accountId,
+        direction: "inbound",
+        at
+    });
+    input.setStatus({
+        accountId: input.accountId,
+        connected: true,
+        lastInboundAt: at,
+        lastError: null
+    });
+    await dispatchInboundMessageToRuntime({
+        runtime: input.runtime,
+        cfg: input.cfg,
+        accountId: input.accountId,
+        threadId,
+        runId,
+        message: inboundMessage,
+        log: input.log
+    });
+}
+function cleanupConsumerIfUnused(consumerKey) {
+    const consumer = workspaceConsumers.get(consumerKey);
+    if (!consumer) {
+        return;
+    }
+    if (consumer.listenerCount() > 0) {
+        return;
+    }
+    consumer.stop();
+    workspaceConsumers.delete(consumerKey);
+}
+async function startLessinboxGatewayAccount(ctx) {
+    const runtime = getLessinboxPluginRuntime();
+    const accountId = deriveAccountRuntimeId(ctx.accountId);
+    if (!runtime) {
+        ctx.setStatus({
+            accountId,
+            running: false,
+            connected: false,
+            lastError: "Lessinbox plugin runtime not initialized"
+        });
+        return;
+    }
+    if (ctx.account.enabled === false) {
+        ctx.setStatus({
+            accountId,
+            running: false,
+            connected: false,
+            lastError: "Lessinbox account is disabled"
+        });
+        return;
+    }
+    const api = new LessinboxApi(ctx.account);
+    const mappingStore = getConversationMappingStore(accountId, ctx.account);
+    const consumer = ensureWorkspaceConsumer(accountId, ctx.account, api, mappingStore);
+    const consumerKey = deriveWorkspaceConsumerRegistryKey(accountId, ctx.account);
+    gatewayUnsubscribers.get(consumerKey)?.();
+    gatewayUnsubscribers.delete(consumerKey);
+    if (!consumer) {
+        ctx.setStatus({
+            accountId,
+            running: false,
+            connected: false,
+            lastError: "Lessinbox workspace stream is disabled"
+        });
+        return;
+    }
+    const unsubscribe = consumer.addListener(async (event) => {
+        await handleGatewayInboundEvent({
+            runtime,
+            cfg: ctx.cfg,
+            api,
+            accountId,
+            mappingStore,
+            event,
+            setStatus: ctx.setStatus,
+            log: ctx.log
+        });
+    });
+    gatewayUnsubscribers.set(consumerKey, unsubscribe);
+    consumer.start();
+    ctx.setStatus({
+        accountId,
+        running: true,
+        connected: true,
+        lastStartAt: Date.now(),
+        lastError: null
+    });
+}
+async function stopLessinboxGatewayAccount(ctx) {
+    const accountId = deriveAccountRuntimeId(ctx.accountId);
+    const consumerKey = deriveWorkspaceConsumerRegistryKey(accountId, ctx.account);
+    const unsubscribe = gatewayUnsubscribers.get(consumerKey);
+    if (unsubscribe) {
+        unsubscribe();
+        gatewayUnsubscribers.delete(consumerKey);
+    }
+    cleanupConsumerIfUnused(consumerKey);
+    ctx.setStatus({
+        accountId,
+        running: false,
+        connected: false,
+        lastStopAt: Date.now()
+    });
+}
 export function subscribeToLessinboxEvents(input) {
     const accountRuntimeId = deriveAccountRuntimeId(input.accountId);
     const account = resolveAccountConfig(input.config, accountRuntimeId);
@@ -678,16 +1305,6 @@ export function subscribeToLessinboxEvents(input) {
     }
     return consumer.addListener(input.onEvent);
 }
-function subscribeFromPlugin(input) {
-    if (!input.config) {
-        throw new Error("Plugin inbound.subscribe did not receive runtime config");
-    }
-    return subscribeToLessinboxEvents({
-        config: input.config,
-        accountId: input.accountId,
-        onEvent: input.onEvent
-    });
-}
 const plugin = {
     id: "lessinbox",
     meta: {
@@ -699,7 +1316,12 @@ const plugin = {
         aliases: ["li", "lessinbox"]
     },
     capabilities: {
-        chatTypes: ["direct", "thread"]
+        chatTypes: ["direct", "thread"],
+        threads: true,
+        media: true
+    },
+    reload: {
+        configPrefixes: ["channels.lessinbox"]
     },
     config: {
         listAccountIds: (cfg) => {
@@ -709,14 +1331,36 @@ const plugin = {
             }
             return Object.keys(accounts);
         },
-        resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId)
+        resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId),
+        isConfigured: (account) => Boolean(account.apiUrl && account.apiKey && account.workspaceId && account.defaultChannelId),
+        describeAccount: (account) => ({
+            accountId: account.accountId ?? "default",
+            enabled: account.enabled !== false,
+            configured: Boolean(account.apiUrl && account.apiKey && account.workspaceId && account.defaultChannelId),
+            workspaceId: account.workspaceId,
+            apiUrl: account.apiUrl
+        })
     },
     outbound: {
         deliveryMode: "direct",
-        sendText: sendTextToLessinbox
+        sendText: sendTextToLessinbox,
+        sendMedia: sendMediaToLessinbox
+    },
+    gateway: {
+        startAccount: startLessinboxGatewayAccount,
+        stopAccount: stopLessinboxGatewayAccount
     },
-    inbound: {
-        subscribe: subscribeFromPlugin
+    status: {
+        defaultRuntime: {
+            accountId: "default",
+            running: false,
+            connected: false,
+            lastConnectedAt: null,
+            lastDisconnect: null,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null
+        }
     }
 };
 export function createLessinboxPlugin() {
@@ -726,10 +1370,15 @@ export default function register(api) {
     if (!api || typeof api.registerChannel !== "function") {
         throw new Error("Openclaw plugin runtime did not expose registerChannel");
     }
+    setLessinboxPluginRuntime(api.runtime);
     api.registerChannel({ plugin });
-    if (typeof api.onShutdown === "function") {
-        api.onShutdown(async () => {
-            await shutdownLessinboxPluginResources();
+    if (typeof api.registerService === "function") {
+        api.registerService({
+            id: "lessinbox-channel-runtime",
+            start: () => undefined,
+            stop: async () => {
+                await shutdownLessinboxPluginResources();
+            }
         });
     }
 }