@evgenyy/lessinbox-channel 0.1.8 → 0.1.10

package/dist/index.js

@@ -1,8 +1,11 @@
 import Redis from "ioredis";
 import WebSocket from "ws";
+import { createHash } from "crypto";
 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(/\/+$/, "");
 }
@@ -26,6 +29,55 @@ function randomIdempotencyKey() {
     }
     return `li_${Date.now()}_${Math.random().toString(36).slice(2)}`;
 }
+function normalizeToCanonicalValue(value) {
+    if (value === null) {
+        return null;
+    }
+    const valueType = typeof value;
+    if (valueType === "string" || valueType === "boolean") {
+        return value;
+    }
+    if (valueType === "number") {
+        const numeric = value;
+        return Number.isFinite(numeric) ? numeric : null;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeToCanonicalValue(entry));
+    }
+    if (valueType === "object") {
+        const record = value;
+        const keys = Object.keys(record).sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+        const normalized = {};
+        for (const key of keys) {
+            const entry = record[key];
+            if (entry === undefined || typeof entry === "function" || typeof entry === "symbol") {
+                continue;
+            }
+            normalized[key] = normalizeToCanonicalValue(entry);
+        }
+        return normalized;
+    }
+    return null;
+}
+function canonicalizeJson(value) {
+    return JSON.stringify(normalizeToCanonicalValue(value));
+}
+function hashCanonicalJson(value, algorithm = "sha256") {
+    const canonicalJson = canonicalizeJson(value);
+    const digest = createHash(algorithm).update(canonicalJson).digest("hex");
+    return `${algorithm}:${digest}`;
+}
+export function hashActionPayload(input) {
+    return hashCanonicalJson({
+        tool: input.tool,
+        action: input.action,
+        request: input.request ?? null,
+        side_effects: input.side_effects ?? null
+    }, "sha256");
+}
 function safeJsonParse(value) {
     try {
         return JSON.parse(value);
@@ -91,10 +143,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 +210,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 +451,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 +541,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 +553,8 @@ export async function shutdownLessinboxPluginResources() {
         await store.close();
     }
     mappingStores.clear();
+    handledInboundMessages.clear();
+    lessinboxPluginRuntime = null;
 }
 export class LessinboxApi {
     constructor(config) {
@@ -510,6 +604,41 @@ export class LessinboxApi {
             idempotencyKey: randomIdempotencyKey()
         });
     }
+    async evaluateGuardrails(input) {
+        return this.request("/v2/guardrails/evaluate", {
+            method: "POST",
+            body: input,
+            idempotencyKey: randomIdempotencyKey()
+        });
+    }
+    async createSimulation(input) {
+        return this.request("/v2/simulate", {
+            method: "POST",
+            body: input,
+            idempotencyKey: randomIdempotencyKey()
+        });
+    }
+    async createApproval(input) {
+        return this.request("/v2/approvals", {
+            method: "POST",
+            body: input,
+            idempotencyKey: randomIdempotencyKey()
+        });
+    }
+    async decideApproval(approvalRequestId, input) {
+        return this.request(`/v2/approvals/${approvalRequestId}/decide`, {
+            method: "POST",
+            body: input,
+            idempotencyKey: randomIdempotencyKey()
+        });
+    }
+    async createExecution(input) {
+        return this.request("/v2/executions", {
+            method: "POST",
+            body: input,
+            idempotencyKey: randomIdempotencyKey()
+        });
+    }
     async completeRun(runId, summary) {
         await this.request(`/v2/runs/${runId}/complete`, {
             method: "POST",
@@ -524,6 +653,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 +673,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 +744,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 +756,219 @@ export function resolveAccountConfig(config, accountId) {
         workspaceStream: resolveWorkspaceStreamConfig(account.workspaceStream)
     };
 }
+export function createLessinboxApiFromConfig(input) {
+    const resolvedAccountId = deriveAccountRuntimeId(input.accountId);
+    const account = resolveAccountConfig(input.config, resolvedAccountId);
+    if (account.enabled === false) {
+        throw new Error(`Lessinbox account '${resolvedAccountId}' is disabled`);
+    }
+    const api = new LessinboxApi(account);
+    return {
+        accountId: resolvedAccountId,
+        account,
+        api
+    };
+}
+function toExecutionErrorPayload(err) {
+    if (err instanceof Error) {
+        const details = {};
+        if (typeof err.stack === "string") {
+            details.stack = err.stack;
+        }
+        return {
+            kind: "execution_error",
+            message: err.message || "Execution failed",
+            ...(Object.keys(details).length > 0 ? { details } : {})
+        };
+    }
+    if (typeof err === "string") {
+        return {
+            kind: "execution_error",
+            message: err
+        };
+    }
+    return {
+        kind: "execution_error",
+        message: "Execution failed",
+        details: {
+            value: err
+        }
+    };
+}
+function buildGuardedExecutionMetadata(input) {
+    return {
+        ...(input.metadata ?? {}),
+        action_hash: input.actionHash,
+        ...(input.approval ? { approval_request_id: input.approval.approval_request_id } : {}),
+        ...(input.simulation
+            ? {
+                simulation_id: input.simulation.simulation_id,
+                simulation_hash: input.simulation.simulation_hash
+            }
+            : {})
+    };
+}
+export async function executeLessinboxGuardedExecution(input) {
+    const { api } = createLessinboxApiFromConfig({
+        config: input.config,
+        accountId: input.accountId
+    });
+    const scope = input.scope ?? {};
+    const actionHash = hashActionPayload({
+        tool: input.tool,
+        action: input.action,
+        request: input.request,
+        side_effects: input.side_effects
+    });
+    const guardrails = await api.evaluateGuardrails({
+        tool: input.tool,
+        action: input.action,
+        request: input.request,
+        side_effects: input.side_effects,
+        metadata: input.metadata,
+        action_hash: actionHash
+    });
+    if (guardrails.decision === "deny") {
+        throw new Error(`Execution blocked by guardrails: ${guardrails.reason}`);
+    }
+    let simulation;
+    if (guardrails.decision === "require_simulation") {
+        simulation = await api.createSimulation({
+            work_item_id: scope.work_item_id ?? null,
+            run_id: scope.run_id ?? null,
+            thread_id: scope.thread_id ?? null,
+            mode: input.simulation_mode,
+            tool: input.tool,
+            action: input.action,
+            request: input.request,
+            side_effects: input.side_effects,
+            metadata: input.metadata,
+            action_hash: actionHash
+        });
+    }
+    let approval;
+    if (guardrails.decision === "require_approval") {
+        approval = await api.createApproval({
+            work_item_id: scope.work_item_id ?? null,
+            run_id: scope.run_id ?? null,
+            thread_id: scope.thread_id ?? null,
+            tool: input.tool,
+            action: input.action,
+            request: input.request,
+            side_effects: input.side_effects,
+            simulation_id: simulation?.simulation_id ?? null,
+            simulation_hash: simulation?.simulation_hash ?? null,
+            reason: input.approval_reason,
+            metadata: input.metadata,
+            action_hash: actionHash
+        });
+        if (input.onApprovalRequired) {
+            await input.onApprovalRequired({
+                approval_request_id: approval.approval_request_id,
+                action_hash: actionHash
+            });
+        }
+    }
+    const executionMetadata = buildGuardedExecutionMetadata({
+        metadata: input.metadata,
+        actionHash,
+        approval,
+        simulation
+    });
+    const preflightExecution = await api.createExecution({
+        work_item_id: scope.work_item_id ?? null,
+        run_id: scope.run_id ?? null,
+        thread_id: scope.thread_id ?? null,
+        tool: input.tool,
+        action: input.action,
+        request: input.request,
+        side_effects: input.side_effects,
+        status: "planned",
+        metadata: executionMetadata
+    });
+    try {
+        const result = await input.execute();
+        const finalExecution = await api.createExecution({
+            work_item_id: scope.work_item_id ?? null,
+            run_id: scope.run_id ?? null,
+            thread_id: scope.thread_id ?? null,
+            tool: input.tool,
+            action: input.action,
+            request: input.request,
+            response: result,
+            side_effects: input.side_effects,
+            status: "succeeded",
+            metadata: executionMetadata
+        });
+        return {
+            action_hash: actionHash,
+            guardrails,
+            simulation,
+            approval,
+            preflight_execution: preflightExecution,
+            final_execution: finalExecution,
+            result
+        };
+    }
+    catch (err) {
+        await api.createExecution({
+            work_item_id: scope.work_item_id ?? null,
+            run_id: scope.run_id ?? null,
+            thread_id: scope.thread_id ?? null,
+            tool: input.tool,
+            action: input.action,
+            request: input.request,
+            side_effects: input.side_effects,
+            status: "failed",
+            error: toExecutionErrorPayload(err),
+            metadata: executionMetadata
+        });
+        throw err;
+    }
+}
+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;
@@ -669,6 +1029,136 @@ function resolveSendTarget(input) {
     // 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");
@@ -694,37 +1184,368 @@ async function sendTextToLessinbox(input) {
     const mappedRun = conversationKey ? await mappingStore.getConversationRun(conversationKey) : undefined;
     let threadId = resolvedThreadId ?? mappedRun?.threadId;
     let runId = resolvedRunId ?? mappedRun?.runId;
-    if (!threadId || !runId) {
-        const title = (input.title && input.title.trim().length > 0 ? input.title.trim() : null) ??
-            input.text.slice(0, 80);
+    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: resolvedChannelId ?? api.getDefaultChannelId(),
+            title: deriveTitle(input),
+            channelId: channelId ?? api.getDefaultChannelId(),
             threadId,
-            metadata: input.metadata
+            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);
@@ -739,16 +1560,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: {
@@ -760,7 +1571,12 @@ const plugin = {
         aliases: ["li", "lessinbox"]
     },
     capabilities: {
-        chatTypes: ["direct", "thread"]
+        chatTypes: ["direct", "thread"],
+        threads: true,
+        media: true
+    },
+    reload: {
+        configPrefixes: ["channels.lessinbox"]
     },
     config: {
         listAccountIds: (cfg) => {
@@ -770,14 +1586,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
     },
-    inbound: {
-        subscribe: subscribeFromPlugin
+    gateway: {
+        startAccount: startLessinboxGatewayAccount,
+        stopAccount: stopLessinboxGatewayAccount
+    },
+    status: {
+        defaultRuntime: {
+            accountId: "default",
+            running: false,
+            connected: false,
+            lastConnectedAt: null,
+            lastDisconnect: null,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null
+        }
     }
 };
 export function createLessinboxPlugin() {
@@ -787,10 +1625,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();
+            }
         });
     }
 }