@alfe.ai/openclaw-chat 0.0.7 → 0.0.8

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;

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,13 +295,33 @@ 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;
 async function handleAgentRequest(request, log) {
@@ -315,36 +330,68 @@ async function handleAgentRequest(request, log) {
 		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}`);
@@ -357,16 +404,17 @@ 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}`);
@@ -432,8 +480,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];
@@ -458,6 +505,7 @@ const plugin = {
 			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.8",
   "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",