@alfe.ai/openclaw-chat 0.0.14 → 0.0.16

package/dist/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_plugin = require("./plugin2.cjs");
+exports.createAlfeChannelPlugin = require_plugin.createAlfeChannelPlugin;
+exports.default = require_plugin.plugin;

package/dist/index.d.cts

@@ -0,0 +1,42 @@
+import { a as AlfeResolvedAccount, i as AlfePluginConfig, n as createAlfeChannelPlugin, r as AlfeChannelConfig, t as plugin } from "./plugin.cjs";
+
+//#region src/session-store.d.ts
+
+/**
+ * Session Store — persists chat sessions to the local filesystem.
+ *
+ * Storage layout:
+ *   ~/.alfe/sessions/chat/{sessionId}.json
+ *
+ * Each session file contains metadata and the full message history.
+ * Sessions are written on every message to ensure durability.
+ * Old sessions are cleaned up automatically (30-day TTL, 1000 max).
+ */
+interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  timestamp: number;
+  senderId?: string;
+  senderName?: string;
+}
+interface SessionData {
+  sessionId: string;
+  agentId: string;
+  channel: string;
+  tenantId?: string;
+  userId?: string;
+  createdAt: string;
+  updatedAt: string;
+  messages: ChatMessage[];
+}
+interface SessionSummary {
+  sessionId: string;
+  agentId: string;
+  channel: string;
+  createdAt: string;
+  lastMessageAt?: string;
+  preview?: string;
+  messageCount: number;
+}
+//#endregion
+export { type AlfeChannelConfig, type AlfePluginConfig, type AlfeResolvedAccount, type ChatMessage, type SessionData, type SessionSummary, createAlfeChannelPlugin, plugin as default };

package/dist/plugin.cjs

@@ -0,0 +1,2 @@
+const require_plugin = require("./plugin2.cjs");
+module.exports = require_plugin.plugin;

package/dist/plugin.d.cts

@@ -0,0 +1,242 @@
+//#region src/types.d.ts
+/**
+ * Types for the Alfe chat channel plugin.
+ *
+ * SDK types (PluginRuntime, OpenClawPluginApi, OpenClawConfig, etc.)
+ * are imported from openclaw/plugin-sdk at usage sites.
+ * This file only contains Alfe-specific domain types.
+ */
+interface AlfeChannelAccountConfig {
+  /** Whether this account is enabled. */
+  enabled?: boolean;
+  /** Allowed sender identifiers (user IDs, email addresses). */
+  allowFrom?: string | string[];
+  /** Default delivery target. */
+  defaultTo?: string;
+  /** DM policy (open, allowlist, etc.). */
+  dmPolicy?: string;
+}
+interface AlfeChannelConfig {
+  /** Whether the Alfe channel is enabled. */
+  enabled?: boolean;
+  /** Allowed sender identifiers. */
+  allowFrom?: string | string[];
+  /** Default delivery target for outbound messages. */
+  defaultTo?: string;
+  /** DM policy. */
+  dmPolicy?: string;
+  /** Named accounts (multi-account support). */
+  accounts?: Record<string, AlfeChannelAccountConfig>;
+}
+interface AlfeResolvedAccount {
+  accountId: string;
+  enabled: boolean;
+  allowFrom: string[];
+  defaultTo?: string;
+  dmPolicy?: string;
+}
+interface AlfePluginConfig {
+  /** Agent ID this plugin is associated with. */
+  agentId?: string;
+  /** Chat service WebSocket URL (e.g. wss://chat.dev.alfe.ai/ws) */
+  chatWsUrl?: string;
+  /** API key for chat service auth */
+  apiKey?: string;
+}
+//#endregion
+//#region src/alfe-channel.d.ts
+/** OpenClaw config shape — inline to avoid runtime dependency on openclaw package */
+interface OpenClawConfig {
+  channels?: {
+    alfe?: AlfeChannelConfig;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+/**
+ * Creates the Alfe ChannelPlugin object for registration with OpenClaw.
+ *
+ * This follows the same pattern as built-in channels (Telegram, Discord, etc.)
+ * but is registered dynamically via api.registerChannel().
+ */
+declare function createAlfeChannelPlugin(): {
+  id: string;
+  meta: {
+    id: string;
+    label: string;
+    selectionLabel: string;
+    detailLabel: string;
+    docsPath: string;
+    docsLabel: string;
+    blurb: string;
+    systemImage: string;
+    order: number;
+    aliases: string[];
+    forceAccountBinding: boolean;
+    showConfigured: boolean;
+  };
+  capabilities: {
+    chatTypes: ("direct" | "group")[];
+    reactions: boolean;
+    edit: boolean;
+    unsend: boolean;
+    reply: boolean;
+    effects: boolean;
+    groupManagement: boolean;
+    threads: boolean;
+    media: boolean;
+    nativeCommands: boolean;
+    polls: boolean;
+  };
+  config: {
+    /**
+     * List configured account IDs.
+     * Supports multi-account via channels.alfe.accounts, with a
+     * default account derived from the top-level channels.alfe section.
+     */
+    listAccountIds(cfg: OpenClawConfig): string[];
+    /**
+     * Resolve account config for a given account ID.
+     */
+    resolveAccount(cfg: OpenClawConfig, accountId?: string | null): AlfeResolvedAccount;
+    /**
+     * Default account ID.
+     */
+    defaultAccountId(): string;
+    /**
+     * Check if account is enabled.
+     */
+    isEnabled(account: AlfeResolvedAccount): boolean;
+    /**
+     * Check if account is configured (always true for Alfe — no external tokens needed).
+     */
+    isConfigured(): boolean;
+    /**
+     * Describe the account state for status display.
+     */
+    describeAccount(account: AlfeResolvedAccount): {
+      accountId: string;
+      enabled: boolean;
+      configured: boolean;
+      dmPolicy: string | undefined;
+    };
+    /**
+     * Resolve allow-from list for an account.
+     */
+    resolveAllowFrom(params: {
+      cfg: OpenClawConfig;
+      accountId?: string | null;
+    }): string[];
+    /**
+     * Resolve default outbound target.
+     */
+    resolveDefaultTo(params: {
+      cfg: OpenClawConfig;
+      accountId?: string | null;
+    }): string | undefined;
+  };
+  /**
+   * Outbound delivery via gateway.
+   * The chat relay service on Fly.io handles actual delivery
+   * to connected web/mobile clients via the gateway.
+   */
+  outbound: {
+    deliveryMode: "gateway";
+    textChunkLimit: number;
+  };
+  /**
+   * Setup adapter — minimal for Alfe since no external tokens are needed.
+   */
+  setup: {
+    resolveAccountId(params: {
+      cfg: OpenClawConfig;
+      accountId?: string;
+      input?: Record<string, unknown>;
+    }): string;
+    applyAccountConfig(params: {
+      cfg: OpenClawConfig;
+      accountId: string;
+      input: Record<string, unknown>;
+    }): OpenClawConfig;
+  };
+};
+//#endregion
+//#region src/plugin.d.ts
+interface PluginLogger {
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+  debug(msg: string, ...args: unknown[]): void;
+}
+interface PluginRuntime {
+  config: {
+    loadConfig(): Record<string, unknown>;
+  };
+  events: {
+    onAgentEvent(listener: (evt: AgentEventPayload) => void): () => void;
+  };
+  subagent: {
+    run(params: {
+      sessionKey: string;
+      message: string;
+      idempotencyKey?: string;
+      deliver?: boolean;
+    }): Promise<{
+      runId: string;
+    }>;
+    waitForRun(params: {
+      runId: string;
+      timeoutMs?: number;
+    }): Promise<{
+      status: string;
+      error?: string;
+    }>;
+  };
+  channel: {
+    routing: {
+      resolveAgentRoute(input: Record<string, unknown>): Record<string, unknown>;
+      buildAgentSessionKey(params: Record<string, unknown>): string;
+    };
+    session: {
+      resolveStorePath(params: Record<string, unknown>): string;
+      readSessionUpdatedAt(params: Record<string, unknown>): number | undefined;
+      recordInboundSession(params: Record<string, unknown>): Promise<void>;
+    };
+    reply: {
+      resolveEnvelopeFormatOptions(cfg: Record<string, unknown>): Record<string, unknown>;
+      formatAgentEnvelope(params: Record<string, unknown>): string;
+      finalizeInboundContext(params: Record<string, unknown>): Record<string, unknown>;
+      dispatchReplyWithBufferedBlockDispatcher(params: Record<string, unknown>): Promise<unknown>;
+      dispatchReplyFromConfig(params: Record<string, unknown>): Promise<unknown>;
+    };
+    [key: string]: unknown;
+  };
+}
+interface AgentEventPayload {
+  runId: string;
+  seq: number;
+  stream: string;
+  ts: number;
+  data: Record<string, unknown>;
+  sessionKey?: string;
+}
+interface PluginApi {
+  logger: PluginLogger;
+  config?: Record<string, unknown>;
+  runtime?: PluginRuntime;
+  registerChannel(channel: ReturnType<typeof createAlfeChannelPlugin>): void;
+  registerGatewayMethod?(name: string, handler: (...args: unknown[]) => Promise<unknown>): void;
+  on(event: string, handler: (...args: unknown[]) => void | Promise<void>, options?: {
+    priority?: number;
+  }): void;
+}
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  activate(api: PluginApi): void;
+  deactivate(api: PluginApi): Promise<void>;
+};
+//#endregion
+export { AlfeResolvedAccount as a, AlfePluginConfig as i, createAlfeChannelPlugin as n, AlfeChannelConfig as r, plugin as t };

package/dist/plugin2.cjs

@@ -0,0 +1,686 @@
+let node_module = require("node:module");
+let _alfe_ai_chat = require("@alfe.ai/chat");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let node_os = require("node:os");
+let node_fs = require("node:fs");
+//#region src/alfe-channel.ts
+const CHANNEL_ID = "alfe";
+const DEFAULT_ACCOUNT_ID = "default";
+function getChannelSection(cfg) {
+	return cfg.channels?.alfe ?? {};
+}
+function normalizeAllowFrom(raw) {
+	if (!raw) return [];
+	if (typeof raw === "string") return [raw];
+	return raw;
+}
+/**
+* Creates the Alfe ChannelPlugin object for registration with OpenClaw.
+*
+* This follows the same pattern as built-in channels (Telegram, Discord, etc.)
+* but is registered dynamically via api.registerChannel().
+*/
+function createAlfeChannelPlugin() {
+	return {
+		id: CHANNEL_ID,
+		meta: {
+			id: CHANNEL_ID,
+			label: "Alfe",
+			selectionLabel: "Alfe (Web & Mobile)",
+			detailLabel: "Alfe",
+			docsPath: "/channels/alfe",
+			docsLabel: "alfe",
+			blurb: "Alfe native chat — web widget and mobile app conversations.",
+			systemImage: "bubble.left.and.text.bubble.right",
+			order: 100,
+			aliases: ["alfe-web", "alfe-mobile"],
+			forceAccountBinding: false,
+			showConfigured: true
+		},
+		capabilities: {
+			chatTypes: ["direct", "group"],
+			reactions: false,
+			edit: false,
+			unsend: false,
+			reply: true,
+			effects: false,
+			groupManagement: false,
+			threads: false,
+			media: true,
+			nativeCommands: false,
+			polls: false
+		},
+		config: {
+			listAccountIds(cfg) {
+				const section = getChannelSection(cfg);
+				const ids = [];
+				if (section.enabled !== false && (section.allowFrom ?? section.defaultTo ?? section.dmPolicy)) ids.push(DEFAULT_ACCOUNT_ID);
+				if (section.accounts) {
+					for (const id of Object.keys(section.accounts)) if (!ids.includes(id)) ids.push(id);
+				}
+				if (ids.length === 0 && section.enabled !== false) ids.push(DEFAULT_ACCOUNT_ID);
+				return ids;
+			},
+			resolveAccount(cfg, accountId) {
+				const section = getChannelSection(cfg);
+				const id = accountId ?? DEFAULT_ACCOUNT_ID;
+				const accountSection = section.accounts?.[id];
+				if (accountSection) return {
+					accountId: id,
+					enabled: accountSection.enabled !== false,
+					allowFrom: normalizeAllowFrom(accountSection.allowFrom),
+					defaultTo: accountSection.defaultTo,
+					dmPolicy: accountSection.dmPolicy
+				};
+				return {
+					accountId: id,
+					enabled: section.enabled !== false,
+					allowFrom: normalizeAllowFrom(section.allowFrom),
+					defaultTo: section.defaultTo,
+					dmPolicy: section.dmPolicy
+				};
+			},
+			defaultAccountId() {
+				return DEFAULT_ACCOUNT_ID;
+			},
+			isEnabled(account) {
+				return account.enabled;
+			},
+			isConfigured() {
+				return true;
+			},
+			describeAccount(account) {
+				return {
+					accountId: account.accountId,
+					enabled: account.enabled,
+					configured: true,
+					dmPolicy: account.dmPolicy
+				};
+			},
+			resolveAllowFrom(params) {
+				const section = getChannelSection(params.cfg);
+				const id = params.accountId ?? DEFAULT_ACCOUNT_ID;
+				return normalizeAllowFrom((section.accounts?.[id])?.allowFrom ?? section.allowFrom);
+			},
+			resolveDefaultTo(params) {
+				const section = getChannelSection(params.cfg);
+				const id = params.accountId ?? DEFAULT_ACCOUNT_ID;
+				return section.accounts?.[id]?.defaultTo ?? section.defaultTo;
+			}
+		},
+		outbound: {
+			deliveryMode: "gateway",
+			textChunkLimit: 4e3
+		},
+		setup: {
+			resolveAccountId(params) {
+				return params.accountId ?? DEFAULT_ACCOUNT_ID;
+			},
+			applyAccountConfig(params) {
+				const cfg = { ...params.cfg };
+				cfg.channels ??= {};
+				cfg.channels.alfe ??= {};
+				const section = cfg.channels.alfe;
+				if (params.accountId === DEFAULT_ACCOUNT_ID) section.enabled = true;
+				else {
+					section.accounts ??= {};
+					section.accounts[params.accountId] = {
+						enabled: true,
+						...params.input
+					};
+				}
+				return cfg;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/session-keys.ts
+/**
+* Session key helpers — handles standardized, canonical, and legacy formats.
+*
+* Standardized format (Alfe-controlled):
+*   alfe:{mode}:{identity}              — single-threaded (SMS, WhatsApp)
+*   alfe:{mode}:{identity}:{convId}     — multi-threaded (web chat)
+*
+* OpenClaw canonical format (from resolveAgentRoute):
+*   agent:{ocAgentId}:alfe:[default:]direct:{senderId}[:thread:{conversationId}]
+*
+* Legacy formats (deprecated):
+*   sms-{agentId}-{phone}
+*   wa-{agentId}-{phone}
+*   chat-{tenantId}-{agentId}-{suffix}
+*   agent:{agentId}:chat-{tenantId}-{agentId}-{suffix}
+*/
+/** Single-threaded channel modes — identity IS the conversation. */
+const SINGLE_THREADED_MODES = new Set([
+	"sms",
+	"whatsapp",
+	"mobile"
+]);
+/**
+* Check if a session key belongs to the Alfe chat channel.
+* Handles standardized, canonical, and legacy formats.
+*/
+function isAlfeSessionKey(key) {
+	if (key.startsWith("alfe:")) return true;
+	if (key.includes(":alfe:")) return true;
+	if (key.includes("chat-") || key.startsWith("sms-") || key.startsWith("wa-")) return true;
+	return false;
+}
+/**
+* Parse session key metadata. Returns available fields from any format.
+*
+* For the callback flow, `conversationId` is the critical field — it maps
+* to the channel registry key used by getChannelCallback().
+*/
+function parseAlfeSessionKey(key) {
+	const standardMatch = /^alfe:(\w+):(.+)$/.exec(key);
+	if (standardMatch) {
+		const [, mode, rest] = standardMatch;
+		if (SINGLE_THREADED_MODES.has(mode)) return {
+			agentId: "",
+			userId: rest,
+			conversationId: key,
+			tenantId: "",
+			mode
+		};
+		const lastColon = rest.lastIndexOf(":");
+		if (lastColon > 0) return {
+			agentId: "",
+			userId: rest.slice(0, lastColon),
+			conversationId: key,
+			tenantId: "",
+			mode
+		};
+		return {
+			agentId: "",
+			userId: rest,
+			conversationId: key,
+			tenantId: "",
+			mode
+		};
+	}
+	const canonicalMatch = /^agent:([^:]+):alfe:(?:default:)?direct:(.+?)(?::thread:(.+))?$/.exec(key);
+	if (canonicalMatch) {
+		const [, matchAgentId, matchUserId, matchConvId] = canonicalMatch;
+		return {
+			agentId: matchAgentId,
+			userId: matchUserId,
+			conversationId: matchConvId || "",
+			tenantId: "",
+			mode: ""
+		};
+	}
+	const rawKey = key.includes(":") ? key.slice(key.lastIndexOf(":") + 1) : key;
+	const legacyMatch = /^chat-([^-]+)-([^-]+)/.exec(rawKey);
+	return {
+		agentId: legacyMatch?.[2] ?? "",
+		userId: "",
+		conversationId: "",
+		tenantId: legacyMatch?.[1] ?? "",
+		mode: "chat"
+	};
+}
+/**
+* Extract the channel mode from a standardized session key or conversationId.
+* Returns the mode segment (e.g. 'sms', 'whatsapp', 'chat') or fallback.
+*/
+function extractChannelMode(conversationId, fallback = "chat") {
+	return /^alfe:(\w+):/.exec(conversationId)?.[1] ?? fallback;
+}
+//#endregion
+//#region src/session-store.ts
+/**
+* Session Store — persists chat sessions to the local filesystem.
+*
+* Storage layout:
+*   ~/.alfe/sessions/chat/{sessionId}.json
+*
+* Each session file contains metadata and the full message history.
+* Sessions are written on every message to ensure durability.
+* Old sessions are cleaned up automatically (30-day TTL, 1000 max).
+*/
+const SESSIONS_DIR = (0, node_path.join)((0, node_os.homedir)(), ".alfe", "sessions", "chat");
+const MAX_SESSIONS = 1e3;
+const MAX_AGE_MS = 720 * 60 * 60 * 1e3;
+const CLEANUP_INTERVAL_MS = 36e5;
+let lastCleanupAt = 0;
+async function ensureDir() {
+	if (!(0, node_fs.existsSync)(SESSIONS_DIR)) await (0, node_fs_promises.mkdir)(SESSIONS_DIR, { recursive: true });
+}
+function sessionPath(sessionId) {
+	return (0, node_path.join)(SESSIONS_DIR, `${sessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+}
+async function cleanupOldSessions() {
+	if (Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return;
+	lastCleanupAt = Date.now();
+	try {
+		const jsonFiles = (await (0, node_fs_promises.readdir)(SESSIONS_DIR)).filter((f) => f.endsWith(".json"));
+		if (jsonFiles.length <= MAX_SESSIONS) {
+			const now = Date.now();
+			for (const file of jsonFiles) try {
+				const filePath = (0, node_path.join)(SESSIONS_DIR, file);
+				if (now - (await (0, node_fs_promises.stat)(filePath)).mtimeMs > MAX_AGE_MS) await (0, node_fs_promises.unlink)(filePath);
+			} catch {}
+			return;
+		}
+		const fileStats = [];
+		for (const file of jsonFiles) try {
+			const filePath = (0, node_path.join)(SESSIONS_DIR, file);
+			const fileStat = await (0, node_fs_promises.stat)(filePath);
+			fileStats.push({
+				path: filePath,
+				mtimeMs: fileStat.mtimeMs
+			});
+		} catch {}
+		fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+		const now = Date.now();
+		let remaining = fileStats.length;
+		for (const entry of fileStats) {
+			if (!(now - entry.mtimeMs > MAX_AGE_MS) && !(remaining > MAX_SESSIONS)) break;
+			try {
+				await (0, node_fs_promises.unlink)(entry.path);
+				remaining--;
+			} catch {}
+		}
+	} catch {}
+}
+async function getSession(sessionId) {
+	try {
+		const data = await (0, node_fs_promises.readFile)(sessionPath(sessionId), "utf-8");
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+async function saveSession(session) {
+	await ensureDir();
+	session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await (0, node_fs_promises.writeFile)(sessionPath(session.sessionId), JSON.stringify(session, null, 2), "utf-8");
+}
+async function createSession(sessionId, agentId, channel, tenantId, userId) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const session = {
+		sessionId,
+		agentId,
+		channel,
+		tenantId,
+		userId,
+		createdAt: now,
+		updatedAt: now,
+		messages: []
+	};
+	await saveSession(session);
+	cleanupOldSessions();
+	return session;
+}
+async function addMessage(sessionId, role, content, senderId, senderName) {
+	const session = await getSession(sessionId);
+	if (!session) return;
+	session.messages.push({
+		role,
+		content,
+		timestamp: Date.now(),
+		...senderId ? { senderId } : {},
+		...senderName ? { senderName } : {}
+	});
+	await saveSession(session);
+}
+async function listSessions(filters, limit = 50) {
+	await ensureDir();
+	let files;
+	try {
+		files = await (0, node_fs_promises.readdir)(SESSIONS_DIR);
+	} catch {
+		return [];
+	}
+	const jsonFiles = files.filter((f) => f.endsWith(".json"));
+	const summaries = [];
+	for (const file of jsonFiles) try {
+		const data = await (0, node_fs_promises.readFile)((0, node_path.join)(SESSIONS_DIR, file), "utf-8");
+		const session = JSON.parse(data);
+		if (filters?.agentId && session.agentId !== filters.agentId) continue;
+		if (filters?.channel && session.channel !== filters.channel) continue;
+		if (filters?.tenantId && session.tenantId !== filters.tenantId) continue;
+		if (filters?.userId && session.userId !== filters.userId) continue;
+		const lastMsg = session.messages.at(-1);
+		summaries.push({
+			sessionId: session.sessionId,
+			agentId: session.agentId,
+			channel: session.channel,
+			createdAt: session.createdAt,
+			lastMessageAt: lastMsg ? new Date(lastMsg.timestamp).toISOString() : void 0,
+			preview: lastMsg?.content.slice(0, 100),
+			messageCount: session.messages.length
+		});
+	} catch {}
+	summaries.sort((a, b) => {
+		const aTime = a.lastMessageAt ?? a.createdAt;
+		return (b.lastMessageAt ?? b.createdAt).localeCompare(aTime);
+	});
+	return summaries.slice(0, limit);
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-chat — OpenClaw chat channel plugin.
+*
+* Registers the 'alfe' channel with OpenClaw. Messages are dispatched
+* through OpenClaw's auto-reply pipeline via dispatchInboundDirectDmWithRuntime(),
+* the same API built-in channels (Slack, Discord, Telegram) use.
+*
+* Architecture:
+*   Chat Service (Fly.io) ←WS→ ChatServiceClient
+*     → dispatchInboundDirectDmWithRuntime() → Agent (auto-reply pipeline)
+*     ← onAgentEvent streaming ← (real-time deltas)
+*     ← deliver() callback ← (final response)
+*/
+let dispatchInbound = null;
+/**
+* Resolve OpenClaw SDK functions from the global install.
+* The openclaw package is installed globally (/usr/lib/node_modules/openclaw/)
+* but is NOT in the plugin's node_modules. Built-in extensions can import
+* directly; external plugins must use createRequire.
+*/
+function resolveOpenClawSdk(log) {
+	for (const globalPath of ["/usr/lib/node_modules/openclaw/package.json", "/usr/local/lib/node_modules/openclaw/package.json"]) try {
+		const channelInbound = (0, node_module.createRequire)(globalPath)("openclaw/plugin-sdk/channel-inbound");
+		if (channelInbound.dispatchInboundDirectDmWithRuntime) {
+			dispatchInbound = channelInbound.dispatchInboundDirectDmWithRuntime;
+			log.info(`Resolved OpenClaw SDK from ${globalPath}`);
+			return;
+		}
+	} catch {}
+	log.warn("OpenClaw SDK not resolvable — chat dispatch will not work");
+}
+let pluginRuntime = null;
+let chatClient = null;
+let connectingPromise = null;
+async function handleAgentRequest(request, log) {
+	const runtime = pluginRuntime;
+	if (!runtime) {
+		chatClient?.sendResponse(request.id, false, { message: "Plugin runtime not initialized" });
+		return;
+	}
+	if (!dispatchInbound) {
+		chatClient?.sendResponse(request.id, false, { message: "OpenClaw SDK not available — cannot dispatch" });
+		return;
+	}
+	const { message, sessionKey: legacySessionKey, userId, conversationId, conversationType, tenantId, clientType, displayName } = request.params;
+	if (!message) {
+		chatClient?.sendResponse(request.id, false, { message: "Missing message" });
+		return;
+	}
+	const senderId = displayName ?? userId ?? "anon";
+	const cfg = runtime.config.loadConfig();
+	const sessionId = conversationId ?? legacySessionKey;
+	if (!await getSession(sessionId)) await createSession(sessionId, "", "alfe", tenantId, userId);
+	await addMessage(sessionId, "user", message, userId ?? senderId, displayName ?? senderId);
+	let resolvedOpenClawKey = null;
+	const unsubscribe = runtime.events.onAgentEvent((evt) => {
+		if (!evt.sessionKey) return;
+		if (evt.stream !== "assistant") return;
+		resolvedOpenClawKey ??= evt.sessionKey;
+		if (evt.sessionKey !== resolvedOpenClawKey) return;
+		chatClient?.sendEvent("chat", {
+			runId: evt.runId,
+			sessionKey: legacySessionKey,
+			seq: evt.seq,
+			state: "delta",
+			message: evt.data
+		});
+	});
+	try {
+		const channelMode = extractChannelMode(conversationId ?? "", clientType ?? "chat");
+		const channelLabel = channelMode === "sms" ? "SMS" : channelMode === "whatsapp" ? "WhatsApp" : "Alfe";
+		const shortConvId = conversationId?.slice(-8) ?? "";
+		const userLabel = displayName ?? userId ?? senderId;
+		const conversationLabel = conversationType === "group" ? shortConvId ? `[${channelLabel}] Group (${shortConvId})` : `[${channelLabel}] Group` : shortConvId ? `[${channelLabel}] ${userLabel} (${shortConvId})` : `[${channelLabel}] ${userLabel}`;
+		resolvedOpenClawKey = (await dispatchInbound({
+			cfg,
+			runtime: { channel: runtime.channel },
+			channel: "alfe",
+			channelLabel,
+			accountId: "default",
+			peer: conversationType === "group" ? {
+				kind: "group",
+				id: conversationId ?? senderId
+			} : {
+				kind: "direct",
+				id: conversationId ? `${senderId}:conv:${conversationId}` : senderId
+			},
+			senderId,
+			senderAddress: `user:${senderId}`,
+			recipientAddress: "agent",
+			conversationLabel,
+			rawBody: message,
+			messageId: request.id,
+			timestamp: Date.now(),
+			extraContext: {
+				...tenantId ? { TenantId: tenantId } : {},
+				...clientType ? { ClientType: clientType } : {},
+				...conversationId ? { ConversationId: conversationId } : {},
+				...displayName ? { SenderName: displayName } : {},
+				ChannelMode: channelMode
+			},
+			deliver: async (payload) => {
+				const responseText = payload.text ?? "";
+				await addMessage(sessionId, "assistant", responseText);
+				chatClient?.sendResponse(request.id, true, {
+					text: responseText,
+					sessionKey: resolvedOpenClawKey ?? legacySessionKey
+				});
+			},
+			onRecordError: (err) => {
+				log.error(`Session record error: ${err instanceof Error ? err.message : String(err)}`);
+			},
+			onDispatchError: (err, info) => {
+				log.error(`Dispatch error (${info.kind}): ${err instanceof Error ? err.message : String(err)}`);
+			}
+		})).route.sessionKey;
+		log.info(`Agent dispatch complete: sessionKey=${resolvedOpenClawKey}`);
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log.error(`Agent dispatch failed: ${errMsg}`);
+		chatClient?.sendResponse(request.id, false, { message: errMsg });
+	} finally {
+		unsubscribe();
+	}
+}
+async function handleSessionsList(request, log) {
+	try {
+		const params = request.params;
+		const sessions = await listSessions({
+			channel: params.channel,
+			tenantId: params.tenantId,
+			userId: params.userId
+		});
+		chatClient?.sendResponse(request.id, true, { sessions });
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log.error(`sessions.list failed: ${errMsg}`);
+		chatClient?.sendResponse(request.id, false, { message: errMsg });
+	}
+}
+async function handleSessionsGet(request, log) {
+	try {
+		const params = request.params;
+		const session = await getSession(params.sessionId);
+		if (!session) {
+			chatClient?.sendResponse(request.id, true, {
+				ok: false,
+				error: "Session not found"
+			});
+			return;
+		}
+		if (params.userId && session.userId && session.userId !== params.userId) {
+			chatClient?.sendResponse(request.id, true, {
+				ok: false,
+				error: "Session not found"
+			});
+			return;
+		}
+		chatClient?.sendResponse(request.id, true, {
+			sessionId: session.sessionId,
+			agentId: session.agentId,
+			channel: session.channel,
+			createdAt: session.createdAt,
+			messages: session.messages.map((m) => ({
+				id: `msg-${String(m.timestamp)}`,
+				role: m.role,
+				content: m.content,
+				timestamp: m.timestamp
+			}))
+		});
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		log.error(`sessions.get failed: ${errMsg}`);
+		chatClient?.sendResponse(request.id, false, { message: errMsg });
+	}
+}
+const plugin = {
+	id: "@alfe.ai/openclaw-chat",
+	name: "Chat Plugin",
+	description: "Chat conversation channel — web widget and mobile app share unified chat sessions",
+	version: "0.0.8",
+	activate(api) {
+		const log = api.logger;
+		const alreadyActivated = globalThis.__alfeChatPluginActivated === true;
+		globalThis.__alfeChatPluginActivated = true;
+		const alfeChannel = createAlfeChannelPlugin();
+		api.registerChannel(alfeChannel);
+		log.info(`Registered channel: ${alfeChannel.id}`);
+		if (!alreadyActivated) {
+			log.info("Chat plugin registering...");
+			resolveOpenClawSdk(log);
+			pluginRuntime = api.runtime ?? null;
+		}
+		const pluginConfig = (((api.config ?? {}).plugins?.entries)?.["@alfe.ai/openclaw-chat"] ?? {}).config ?? {};
+		if (!alreadyActivated) connectingPromise = Promise.resolve().then(() => {
+			try {
+				const { apiKey, chatWsUrl } = (0, _alfe_ai_chat.resolveAlfeChat)({
+					apiKey: pluginConfig.apiKey,
+					chatWsUrl: pluginConfig.chatWsUrl
+				});
+				if (chatWsUrl && apiKey) {
+					log.info(`Connecting to chat service: ${chatWsUrl}`);
+					chatClient = new _alfe_ai_chat.ChatServiceClient({
+						wsUrl: chatWsUrl,
+						apiKey,
+						onRequest: (request) => {
+							if (request.method === "agent") handleAgentRequest(request, log);
+							else if (request.method === "sessions.list") handleSessionsList(request, log);
+							else if (request.method === "sessions.get") handleSessionsGet(request, log);
+							else chatClient?.sendResponse(request.id, false, { message: `Unknown method: ${request.method}` });
+						},
+						onConnectionChange: (connected) => {
+							log.info(`Chat service connection: ${connected ? "connected" : "disconnected"}`);
+						},
+						logger: log
+					});
+					chatClient.start();
+					log.info("Chat service relay started");
+				} else log.info("Chat service URL not configured — running without chat service relay");
+			} catch (err) {
+				log.error(`Failed to initialize chat service: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		});
+		if (typeof api.registerGatewayMethod === "function") {
+			api.registerGatewayMethod("sessions.list", async (...args) => {
+				const params = args[0];
+				return { sessions: await listSessions({
+					channel: params.channel,
+					tenantId: params.tenantId,
+					userId: params.userId
+				}) };
+			});
+			api.registerGatewayMethod("sessions.get", async (...args) => {
+				const params = args[0];
+				const session = await getSession(params.sessionId);
+				if (!session) return {
+					ok: false,
+					error: "Session not found"
+				};
+				if (params.userId && session.userId && session.userId !== params.userId) return {
+					ok: false,
+					error: "Session not found"
+				};
+				return {
+					sessionId: session.sessionId,
+					agentId: session.agentId,
+					channel: session.channel,
+					createdAt: session.createdAt,
+					messages: session.messages.map((m) => ({
+						id: `msg-${String(m.timestamp)}`,
+						role: m.role,
+						content: m.content,
+						timestamp: m.timestamp
+					}))
+				};
+			});
+			log.info("Registered gateway RPC methods: sessions.list, sessions.get");
+		}
+		if (!alreadyActivated) {
+			api.on("session_start", async (...eventArgs) => {
+				const key = eventArgs[0].sessionKey;
+				if (!key || isAlfeSessionKey(key)) return;
+				log.info(`Chat session starting: ${key}`);
+				await createSession(key, "", "alfe");
+			}, { priority: 50 });
+			api.on("message", async (...eventArgs) => {
+				const event = eventArgs[0];
+				const key = event.sessionKey;
+				if (!key) return;
+				if (isAlfeSessionKey(key)) {
+					if (event.role === "assistant" && chatClient) {
+						const parsed = parseAlfeSessionKey(key);
+						if (parsed.conversationId) chatClient.notify("agent-message", {
+							conversationId: parsed.conversationId,
+							text: event.content
+						});
+					}
+				} else await addMessage(key, event.role, event.content);
+			});
+			api.on("session_end", (...eventArgs) => {
+				const key = eventArgs[0].sessionKey;
+				if (!key || !isAlfeSessionKey(key)) return;
+				log.info(`Chat session ending: ${key}`);
+			});
+		}
+		log.info("Chat plugin registered");
+	},
+	async deactivate(api) {
+		globalThis.__alfeChatPluginActivated = false;
+		const log = api.logger;
+		log.info("Chat plugin deactivating...");
+		if (connectingPromise) {
+			await connectingPromise.catch((err) => {
+				api.logger.debug(`Connection attempt failed: ${err instanceof Error ? err.message : String(err)}`);
+			});
+			connectingPromise = null;
+		}
+		if (chatClient) {
+			chatClient.stop();
+			chatClient = null;
+			log.info("Chat service client stopped");
+		}
+		pluginRuntime = null;
+		dispatchInbound = null;
+		log.info("Chat plugin deactivated");
+	}
+};
+//#endregion
+Object.defineProperty(exports, "createAlfeChannelPlugin", {
+	enumerable: true,
+	get: function() {
+		return createAlfeChannelPlugin;
+	}
+});
+Object.defineProperty(exports, "plugin", {
+	enumerable: true,
+	get: function() {
+		return plugin;
+	}
+});

package/dist/plugin2.d.cts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.cjs";
+export { plugin as default };

package/dist/plugin2.js

@@ -138,28 +138,98 @@ function createAlfeChannelPlugin() {
 //#endregion
 //#region src/session-keys.ts
 /**
-* Session key helpers — handles both legacy and canonical OpenClaw formats.
+* Session key helpers — handles standardized, canonical, and legacy formats.
 *
-* Canonical format (from resolveAgentRoute):
-*   agent:{agentId}:alfe:direct:{userId}
-*   agent:{agentId}:alfe:direct:{userId}:thread:{conversationId}
+* Standardized format (Alfe-controlled):
+*   alfe:{mode}:{identity}              — single-threaded (SMS, WhatsApp)
+*   alfe:{mode}:{identity}:{convId}     — multi-threaded (web chat)
 *
-* Legacy format (from chat adapter):
+* OpenClaw canonical format (from resolveAgentRoute):
+*   agent:{ocAgentId}:alfe:[default:]direct:{senderId}[:thread:{conversationId}]
+*
+* Legacy formats (deprecated):
+*   sms-{agentId}-{phone}
+*   wa-{agentId}-{phone}
 *   chat-{tenantId}-{agentId}-{suffix}
 *   agent:{agentId}:chat-{tenantId}-{agentId}-{suffix}
-*
-* The plugin may receive either format depending on which
-* OpenClaw event fires and whether the new dispatch path is active.
 */
+/** Single-threaded channel modes — identity IS the conversation. */
+const SINGLE_THREADED_MODES = new Set([
+	"sms",
+	"whatsapp",
+	"mobile"
+]);
 /**
 * Check if a session key belongs to the Alfe chat channel.
-* Handles both canonical and legacy formats.
+* Handles standardized, canonical, and legacy formats.
 */
 function isAlfeSessionKey(key) {
+	if (key.startsWith("alfe:")) return true;
 	if (key.includes(":alfe:")) return true;
-	if (key.includes("chat-")) return true;
+	if (key.includes("chat-") || key.startsWith("sms-") || key.startsWith("wa-")) return true;
 	return false;
 }
+/**
+* Parse session key metadata. Returns available fields from any format.
+*
+* For the callback flow, `conversationId` is the critical field — it maps
+* to the channel registry key used by getChannelCallback().
+*/
+function parseAlfeSessionKey(key) {
+	const standardMatch = /^alfe:(\w+):(.+)$/.exec(key);
+	if (standardMatch) {
+		const [, mode, rest] = standardMatch;
+		if (SINGLE_THREADED_MODES.has(mode)) return {
+			agentId: "",
+			userId: rest,
+			conversationId: key,
+			tenantId: "",
+			mode
+		};
+		const lastColon = rest.lastIndexOf(":");
+		if (lastColon > 0) return {
+			agentId: "",
+			userId: rest.slice(0, lastColon),
+			conversationId: key,
+			tenantId: "",
+			mode
+		};
+		return {
+			agentId: "",
+			userId: rest,
+			conversationId: key,
+			tenantId: "",
+			mode
+		};
+	}
+	const canonicalMatch = /^agent:([^:]+):alfe:(?:default:)?direct:(.+?)(?::thread:(.+))?$/.exec(key);
+	if (canonicalMatch) {
+		const [, matchAgentId, matchUserId, matchConvId] = canonicalMatch;
+		return {
+			agentId: matchAgentId,
+			userId: matchUserId,
+			conversationId: matchConvId || "",
+			tenantId: "",
+			mode: ""
+		};
+	}
+	const rawKey = key.includes(":") ? key.slice(key.lastIndexOf(":") + 1) : key;
+	const legacyMatch = /^chat-([^-]+)-([^-]+)/.exec(rawKey);
+	return {
+		agentId: legacyMatch?.[2] ?? "",
+		userId: "",
+		conversationId: "",
+		tenantId: legacyMatch?.[1] ?? "",
+		mode: "chat"
+	};
+}
+/**
+* Extract the channel mode from a standardized session key or conversationId.
+* Returns the mode segment (e.g. 'sms', 'whatsapp', 'chat') or fallback.
+*/
+function extractChannelMode(conversationId, fallback = "chat") {
+	return /^alfe:(\w+):/.exec(conversationId)?.[1] ?? fallback;
+}
 //#endregion
 //#region src/session-store.ts
 /**
@@ -274,6 +344,7 @@ async function listSessions(filters, limit = 50) {
 		if (filters?.agentId && session.agentId !== filters.agentId) continue;
 		if (filters?.channel && session.channel !== filters.channel) continue;
 		if (filters?.tenantId && session.tenantId !== filters.tenantId) continue;
+		if (filters?.userId && session.userId !== filters.userId) continue;
 		const lastMsg = session.messages.at(-1);
 		summaries.push({
 			sessionId: session.sessionId,
@@ -362,14 +433,16 @@ async function handleAgentRequest(request, log) {
 		});
 	});
 	try {
+		const channelMode = extractChannelMode(conversationId ?? "", clientType ?? "chat");
+		const channelLabel = channelMode === "sms" ? "SMS" : channelMode === "whatsapp" ? "WhatsApp" : "Alfe";
 		const shortConvId = conversationId?.slice(-8) ?? "";
 		const userLabel = displayName ?? userId ?? senderId;
-		const conversationLabel = conversationType === "group" ? shortConvId ? `[Alfe] Group (${shortConvId})` : "[Alfe] Group" : shortConvId ? `[Alfe] ${userLabel} (${shortConvId})` : `[Alfe] ${userLabel}`;
+		const conversationLabel = conversationType === "group" ? shortConvId ? `[${channelLabel}] Group (${shortConvId})` : `[${channelLabel}] Group` : shortConvId ? `[${channelLabel}] ${userLabel} (${shortConvId})` : `[${channelLabel}] ${userLabel}`;
 		resolvedOpenClawKey = (await dispatchInbound({
 			cfg,
 			runtime: { channel: runtime.channel },
 			channel: "alfe",
-			channelLabel: "Alfe",
+			channelLabel,
 			accountId: "default",
 			peer: conversationType === "group" ? {
 				kind: "group",
@@ -389,7 +462,8 @@ async function handleAgentRequest(request, log) {
 				...tenantId ? { TenantId: tenantId } : {},
 				...clientType ? { ClientType: clientType } : {},
 				...conversationId ? { ConversationId: conversationId } : {},
-				...displayName ? { SenderName: displayName } : {}
+				...displayName ? { SenderName: displayName } : {},
+				ChannelMode: channelMode
 			},
 			deliver: async (payload) => {
 				const responseText = payload.text ?? "";
@@ -420,7 +494,8 @@ async function handleSessionsList(request, log) {
 		const params = request.params;
 		const sessions = await listSessions({
 			channel: params.channel,
-			tenantId: params.tenantId
+			tenantId: params.tenantId,
+			userId: params.userId
 		});
 		chatClient?.sendResponse(request.id, true, { sessions });
 	} catch (err) {
@@ -440,6 +515,13 @@ async function handleSessionsGet(request, log) {
 			});
 			return;
 		}
+		if (params.userId && session.userId && session.userId !== params.userId) {
+			chatClient?.sendResponse(request.id, true, {
+				ok: false,
+				error: "Session not found"
+			});
+			return;
+		}
 		chatClient?.sendResponse(request.id, true, {
 			sessionId: session.sessionId,
 			agentId: session.agentId,
@@ -510,7 +592,8 @@ const plugin = {
 				const params = args[0];
 				return { sessions: await listSessions({
 					channel: params.channel,
-					tenantId: params.tenantId
+					tenantId: params.tenantId,
+					userId: params.userId
 				}) };
 			});
 			api.registerGatewayMethod("sessions.get", async (...args) => {
@@ -520,6 +603,10 @@ const plugin = {
 					ok: false,
 					error: "Session not found"
 				};
+				if (params.userId && session.userId && session.userId !== params.userId) return {
+					ok: false,
+					error: "Session not found"
+				};
 				return {
 					sessionId: session.sessionId,
 					agentId: session.agentId,
@@ -545,8 +632,16 @@ const plugin = {
 			api.on("message", async (...eventArgs) => {
 				const event = eventArgs[0];
 				const key = event.sessionKey;
-				if (!key || isAlfeSessionKey(key)) return;
-				await addMessage(key, event.role, event.content);
+				if (!key) return;
+				if (isAlfeSessionKey(key)) {
+					if (event.role === "assistant" && chatClient) {
+						const parsed = parseAlfeSessionKey(key);
+						if (parsed.conversationId) chatClient.notify("agent-message", {
+							conversationId: parsed.conversationId,
+							text: event.content
+						});
+					}
+				} else await addMessage(key, event.role, event.content);
 			});
 			api.on("session_end", (...eventArgs) => {
 				const key = eventArgs[0].sessionKey;

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@alfe.ai/openclaw-chat",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
   "type": "module",
   "main": "./dist/plugin.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     },
     "./plugin": {
-      "import": "./dist/plugin.js",
-      "types": "./dist/plugin.d.ts"
+      "types": "./dist/plugin.d.ts",
+      "require": "./dist/plugin.cjs",
+      "import": "./dist/plugin.js"
     }
   },
   "openclaw": {
@@ -25,7 +27,7 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@alfe.ai/chat": "^0.0.4"
+    "@alfe.ai/chat": "^0.0.6"
   },
   "peerDependencies": {
     "openclaw": ">=2026.3.0"