@alfe.ai/openclaw-chat 0.0.7 → 0.0.9

package/dist/plugin.d.ts

@@ -192,7 +192,25 @@ interface PluginRuntime {
       error?: string;
     }>;
   };
-  channel: unknown;
+  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;
@@ -218,7 +236,7 @@ declare const plugin: {
   description: string;
   version: string;
   activate(api: PluginApi): void;
-  deactivate(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.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { ChatServiceClient, resolveAlfeChat } from "@alfe.ai/chat";
 import { mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -137,33 +138,27 @@ function createAlfeChannelPlugin() {
 //#endregion
 //#region src/session-keys.ts
 /**
-* Session key helpers — handles both raw and prefixed formats.
+* Session key helpers — handles both legacy and canonical OpenClaw formats.
 *
-* Raw format:     "chat-{tenantId}-{agentId}-{suffix}"
-* Prefixed format: "agent:{agentId}:chat-{tenantId}-{agentId}-{suffix}"
+* Canonical format (from resolveAgentRoute):
+*   agent:{agentId}:alfe:direct:{userId}
+*   agent:{agentId}:alfe:direct:{userId}:thread:{conversationId}
 *
-* The chat adapter wraps keys with "agent:{agentId}:" before sending
-* to the daemon. The plugin may receive either format depending on
-* which OpenClaw event fires.
+* Legacy format (from chat adapter):
+*   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.
 */
 /**
 * Check if a session key belongs to the Alfe chat channel.
-* Handles both raw and prefixed formats.
+* Handles both canonical and legacy formats.
 */
 function isAlfeSessionKey(key) {
-	return key.includes("chat-") || key.includes("alfe:") || key.includes(":alfe:");
-}
-/**
-* Strip the "agent:{agentId}:" prefix and extract tenantId + agentId.
-* Returns empty strings if the key doesn't match the expected format.
-*/
-function parseAlfeSessionKey(key) {
-	const rawKey = key.includes(":") ? key.slice(key.lastIndexOf(":") + 1) : key;
-	const match = /^chat-([^-]+)-([^-]+)/.exec(rawKey);
-	return {
-		tenantId: match?.[1] ?? "",
-		agentId: match?.[2] ?? ""
-	};
+	if (key.includes(":alfe:")) return true;
+	if (key.includes("chat-")) return true;
+	return false;
 }
 //#endregion
 //#region src/session-store.ts
@@ -300,51 +295,104 @@ async function listSessions(filters, limit = 50) {
 * @alfe.ai/openclaw-chat — OpenClaw chat channel plugin.
 *
 * Registers the 'alfe' channel with OpenClaw. Messages are dispatched
-* in-process via runtime.subagent.run() — no separate WebSocket to the
-* runtime needed.
+* 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 → runtime.subagent.run() → Agent (in-process)
-*                               ← onAgentEvent streaming ←
+*   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 = 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;
 	}
-	const { message, sessionKey } = request.params;
-	if (!message || !sessionKey) {
-		chatClient?.sendResponse(request.id, false, { message: "Missing message or sessionKey" });
+	if (!dispatchInbound) {
+		chatClient?.sendResponse(request.id, false, { message: "OpenClaw SDK not available — cannot dispatch" });
 		return;
 	}
+	const { message, sessionKey: legacySessionKey, userId, conversationId, tenantId, clientType } = request.params;
+	if (!message) {
+		chatClient?.sendResponse(request.id, false, { message: "Missing message" });
+		return;
+	}
+	const senderId = userId ?? `anon-${legacySessionKey.slice(0, 12)}`;
+	const cfg = runtime.config.loadConfig();
+	let resolvedSessionKey = legacySessionKey;
 	const unsubscribe = runtime.events.onAgentEvent((evt) => {
-		if (evt.sessionKey !== sessionKey) return;
+		if (!evt.sessionKey) return;
+		if (resolvedSessionKey && evt.sessionKey !== resolvedSessionKey) return;
 		if (evt.stream === "assistant") chatClient?.sendEvent("chat", {
 			runId: evt.runId,
-			sessionKey,
+			sessionKey: evt.sessionKey,
 			seq: evt.seq,
 			state: "delta",
 			message: evt.data
 		});
 	});
 	try {
-		const { runId } = await runtime.subagent.run({
-			sessionKey,
-			message,
-			deliver: true
-		});
-		const result = await runtime.subagent.waitForRun({
-			runId,
-			timeoutMs: 12e4
-		});
-		if (result.status === "ok") chatClient?.sendResponse(request.id, true, {
-			text: "",
-			sessionKey
-		});
-		else chatClient?.sendResponse(request.id, false, { message: result.error ?? `Agent run ${result.status}` });
+		const conversationLabel = userId ? `Chat with ${userId}` : `Alfe chat`;
+		resolvedSessionKey = (await dispatchInbound({
+			cfg,
+			runtime: { channel: runtime.channel },
+			channel: "alfe",
+			channelLabel: "Alfe",
+			accountId: "default",
+			peer: {
+				kind: "direct",
+				id: 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 } : {}
+			},
+			deliver: (payload) => {
+				chatClient?.sendResponse(request.id, true, {
+					text: payload.text ?? "",
+					sessionKey: resolvedSessionKey
+				});
+				return Promise.resolve();
+			},
+			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=${resolvedSessionKey}`);
 	} catch (err) {
 		const errMsg = err instanceof Error ? err.message : String(err);
 		log.error(`Agent dispatch failed: ${errMsg}`);
@@ -353,25 +401,70 @@ async function handleAgentRequest(request, log) {
 		unsubscribe();
 	}
 }
+async function handleSessionsList(request, log) {
+	try {
+		const params = request.params;
+		const sessions = await listSessions({
+			agentId: params.agentId,
+			channel: params.channel,
+			tenantId: params.tenantId
+		});
+		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;
+		}
+		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: "Alfe Chat Plugin",
 	description: "Alfe conversation channel — web widget and mobile app share unified chat sessions",
-	version: "0.3.0",
+	version: "0.0.8",
 	activate(api) {
 		if (globalThis.__alfeChatPluginActivated) {
 			api.logger.debug("Alfe Chat plugin already activated, skipping re-init");
 			return;
 		}
 		globalThis.__alfeChatPluginActivated = true;
-		pluginRuntime = api.runtime ?? null;
 		const log = api.logger;
 		log.info("Alfe Chat plugin registering...");
+		resolveOpenClawSdk(log);
+		pluginRuntime = api.runtime ?? null;
 		const alfeChannel = createAlfeChannelPlugin();
 		api.registerChannel(alfeChannel);
 		log.info(`Registered channel: ${alfeChannel.id}`);
 		const pluginConfig = (((api.config ?? {}).plugins?.entries)?.["@alfe.ai/openclaw-chat"] ?? {}).config ?? {};
-		(async () => {
+		connectingPromise = (async () => {
 			try {
 				const { apiKey, chatWsUrl } = await resolveAlfeChat({
 					apiKey: pluginConfig.apiKey,
@@ -384,6 +477,9 @@ const plugin = {
 						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"}`);
@@ -432,8 +528,7 @@ const plugin = {
 			const key = eventArgs[0].sessionKey;
 			if (!key || !isAlfeSessionKey(key)) return;
 			log.info(`Alfe chat session starting: ${key}`);
-			const { tenantId, agentId: parsedAgentId } = parseAlfeSessionKey(key);
-			await createSession(key, parsedAgentId, "alfe", tenantId);
+			await createSession(key, "", "alfe");
 		}, { priority: 50 });
 		api.on("message", async (...eventArgs) => {
 			const event = eventArgs[0];
@@ -448,16 +543,23 @@ const plugin = {
 		});
 		log.info("Alfe Chat plugin registered");
 	},
-	deactivate(api) {
+	async deactivate(api) {
 		globalThis.__alfeChatPluginActivated = false;
 		const log = api.logger;
 		log.info("Alfe 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("Alfe Chat plugin deactivated");
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/openclaw-chat",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
   "type": "module",
   "main": "./dist/plugin.js",
@@ -27,6 +27,14 @@
   "dependencies": {
     "@alfe.ai/chat": "^0.0.3"
   },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.0"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
   "license": "UNLICENSED",
   "scripts": {
     "build": "tsdown",