@alfe.ai/openclaw-chat 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as AlfeResolvedAccount, c as OpenClawConfig, d as createAlfeChannelPlugin, i as AlfePluginConfig, l as OpenClawModule, n as AlfeChannelAccountConfig, o as IPCClient, r as AlfeChannelConfig, s as Logger, t as plugin, u as OpenClawPluginApi } from "./plugin.js";
+import { a as AlfeResolvedAccount, i as AlfePluginConfig, n as createAlfeChannelPlugin, r as AlfeChannelConfig, t as plugin } from "./plugin.js";
 
 //#region src/session-store.d.ts
 
@@ -10,6 +10,7 @@ import { a as AlfeResolvedAccount, c as OpenClawConfig, d as createAlfeChannelPl
  *
  * 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';
@@ -36,4 +37,4 @@ interface SessionSummary {
   messageCount: number;
 }
 //#endregion
-export { AlfeChannelAccountConfig, AlfeChannelConfig, AlfePluginConfig, AlfeResolvedAccount, type ChatMessage, IPCClient, Logger, OpenClawConfig, OpenClawModule, OpenClawPluginApi, type SessionData, type SessionSummary, createAlfeChannelPlugin, plugin as default, plugin };
+export { type AlfeChannelConfig, type AlfePluginConfig, type AlfeResolvedAccount, type ChatMessage, type SessionData, type SessionSummary, createAlfeChannelPlugin, plugin as default };

package/dist/index.js

@@ -1,2 +1,2 @@
 import { n as createAlfeChannelPlugin, t as plugin } from "./plugin2.js";
-export { createAlfeChannelPlugin, plugin as default, plugin };
+export { createAlfeChannelPlugin, plugin as default };

package/dist/plugin.d.ts

@@ -1,5 +1,58 @@
+//#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.
  *
@@ -108,106 +161,64 @@ declare function createAlfeChannelPlugin(): {
   };
 };
 //#endregion
-//#region src/types.d.ts
-/**
- * Types for the Alfe chat channel plugin.
- *
- * The Alfe channel registers with OpenClaw as a first-class channel,
- * allowing web and mobile clients to share conversation sessions.
- */
-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 {
-  /** Alfe daemon IPC socket path override. */
-  daemonSocket?: string;
-  /** 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;
-  /** OpenClaw local gateway URL override (default: ws://127.0.0.1:18789) */
-  openclawGatewayUrl?: string;
-}
-interface Logger {
+//#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 OpenClawConfig {
-  channels?: {
-    alfe?: AlfeChannelConfig;
-    [key: string]: unknown;
+interface PluginRuntime {
+  config: {
+    loadConfig(): Record<string, unknown>;
+  };
+  events: {
+    onAgentEvent(listener: (evt: AgentEventPayload) => void): () => void;
   };
-  plugins?: {
-    entries?: Record<string, {
-      config?: AlfePluginConfig;
-      [key: string]: unknown;
+  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;
     }>;
-    [key: string]: unknown;
   };
-  [key: string]: unknown;
+  channel: unknown;
+}
+interface AgentEventPayload {
+  runId: string;
+  seq: number;
+  stream: string;
+  ts: number;
+  data: Record<string, unknown>;
+  sessionKey?: string;
 }
-interface OpenClawPluginApi {
-  logger: Logger;
-  config?: OpenClawConfig;
+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;
 }
-interface IPCClient {
-  on(event: string, handler: (...args: unknown[]) => void | Promise<void>): void;
-  start(): void;
-  stop(): void;
-  request(method: string, params: Record<string, unknown>): Promise<{
-    ok: boolean;
-    error?: {
-      message: string;
-    };
-  }>;
-}
-interface OpenClawModule {
-  IPCClient: new (socketPath: string, log: Logger) => IPCClient;
-}
-//#endregion
-//#region src/plugin.d.ts
 declare const plugin: {
   id: string;
   name: string;
   description: string;
   version: string;
-  activate(api: OpenClawPluginApi): Promise<void>;
-  deactivate(api: OpenClawPluginApi): void;
+  activate(api: PluginApi): void;
+  deactivate(api: PluginApi): void;
 };
 //#endregion
-export { AlfeResolvedAccount as a, OpenClawConfig as c, createAlfeChannelPlugin as d, AlfePluginConfig as i, OpenClawModule as l, AlfeChannelAccountConfig as n, IPCClient as o, AlfeChannelConfig as r, Logger as s, plugin as t, OpenClawPluginApi as u };
+export { AlfeResolvedAccount as a, AlfePluginConfig as i, createAlfeChannelPlugin as n, AlfeChannelConfig as r, plugin as t };

package/dist/plugin2.js

@@ -1,9 +1,7 @@
+import { ChatServiceClient, resolveAlfeChat } from "@alfe.ai/chat";
+import { mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { ChatServiceClient, resolveAlfeChat } from "@alfe.ai/chat";
-import WebSocket from "ws";
-import { randomUUID } from "node:crypto";
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 //#region src/alfe-channel.ts
 const CHANNEL_ID = "alfe";
@@ -137,238 +135,36 @@ function createAlfeChannelPlugin() {
 	};
 }
 //#endregion
-//#region src/runtime-relay.ts
+//#region src/session-keys.ts
 /**
-* RuntimeRelay — bridges the chat service to the local OpenClaw runtime.
+* Session key helpers — handles both raw and prefixed formats.
 *
-* Connects to OpenClaw's local WebSocket server (typically ws://127.0.0.1:18789),
-* performs the protocol handshake, and forwards RPC requests from the chat
-* service to the runtime. Responses and streaming events are routed back
-* via callbacks.
+* Raw format:     "chat-{tenantId}-{agentId}-{suffix}"
+* Prefixed format: "agent:{agentId}:chat-{tenantId}-{agentId}-{suffix}"
 *
-* Modeled after the voice relay's LocalGatewayClient pattern.
+* 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.
 */
-const RECONNECT_DELAYS = [
-	500,
-	1e3,
-	2e3,
-	4e3,
-	8e3,
-	15e3,
-	3e4
-];
-var RuntimeRelay = class {
-	ws = null;
-	pending = /* @__PURE__ */ new Map();
-	connected = false;
-	stopped = false;
-	retryCount = 0;
-	retryTimer = null;
-	connectSent = false;
-	wsUrl;
-	token;
-	log;
-	constructor(options) {
-		this.options = options;
-		this.wsUrl = options.wsUrl ?? "ws://127.0.0.1:18789";
-		this.token = options.token ?? "";
-		this.log = options.logger;
-	}
-	get isConnected() {
-		return this.connected && this.ws?.readyState === WebSocket.OPEN;
-	}
-	start() {
-		this.log.debug("RuntimeRelay starting...");
-		this.stopped = false;
-		this.doConnect();
-	}
-	stop() {
-		this.log.debug("RuntimeRelay stopping...");
-		this.stopped = true;
-		if (this.retryTimer) {
-			clearTimeout(this.retryTimer);
-			this.retryTimer = null;
-		}
-		if (this.ws) {
-			try {
-				this.ws.close(1e3);
-			} catch {}
-			this.ws = null;
-		}
-		this.connected = false;
-		this.flushPending(/* @__PURE__ */ new Error("RuntimeRelay stopped"));
-	}
-	/**
-	* Forward an RPC request from the chat service to the runtime.
-	* The response routes back via the callback.
-	*/
-	forwardRequest(msg, onResponse) {
-		if (this.ws?.readyState !== WebSocket.OPEN) {
-			onResponse({
-				id: msg.id,
-				ok: false,
-				error: { message: "Runtime not connected" }
-			});
-			return;
-		}
-		const timeoutMs = msg.method === "agent" ? 13e4 : 3e4;
-		const timer = setTimeout(() => {
-			this.pending.delete(msg.id);
-			onResponse({
-				id: msg.id,
-				ok: false,
-				error: { message: `'${msg.method}' timed out` }
-			});
-		}, timeoutMs);
-		this.pending.set(msg.id, {
-			resolve: (payload) => {
-				clearTimeout(timer);
-				onResponse({
-					id: msg.id,
-					ok: true,
-					payload
-				});
-			},
-			reject: (err) => {
-				clearTimeout(timer);
-				onResponse({
-					id: msg.id,
-					ok: false,
-					error: { message: err.message }
-				});
-			},
-			expectFinal: msg.method === "agent"
-		});
-		this.ws.send(JSON.stringify({
-			type: "req",
-			id: msg.id,
-			method: msg.method,
-			params: msg.params
-		}));
-	}
-	doConnect() {
-		if (this.stopped) return;
-		this.log.info(`Connecting to runtime at ${this.wsUrl}...`);
-		this.ws = new WebSocket(this.wsUrl, { maxPayload: 25 * 1024 * 1024 });
-		this.ws.on("open", () => {
-			this.log.info("Connected to runtime — authenticating...");
-			this.retryCount = 0;
-			setTimeout(() => {
-				this.sendConnect();
-			}, 750);
-		});
-		this.ws.on("message", (data) => {
-			const text = Buffer.isBuffer(data) ? data.toString("utf-8") : Buffer.from(data).toString("utf-8");
-			this.handleMessage(text);
-		});
-		this.ws.on("close", (code) => {
-			this.log.warn(`Runtime disconnected (${String(code)})`);
-			this.connected = false;
-			this.flushPending(/* @__PURE__ */ new Error(`Runtime closed (${String(code)})`));
-			this.scheduleReconnect();
-		});
-		this.ws.on("error", (err) => {
-			this.log.error(`Runtime WS error: ${err.message}`);
-		});
-	}
-	async sendConnect() {
-		if (this.connectSent) return;
-		this.connectSent = true;
-		const id = randomUUID();
-		const timeoutMs = 1e4;
-		try {
-			await new Promise((resolve, reject) => {
-				const timer = setTimeout(() => {
-					this.pending.delete(id);
-					reject(/* @__PURE__ */ new Error("Connect handshake timed out"));
-				}, timeoutMs);
-				this.pending.set(id, {
-					resolve: () => {
-						clearTimeout(timer);
-						resolve();
-					},
-					reject: (err) => {
-						clearTimeout(timer);
-						reject(err);
-					},
-					expectFinal: false
-				});
-				this.ws?.send(JSON.stringify({
-					type: "req",
-					id,
-					method: "connect",
-					params: {
-						minProtocol: 3,
-						maxProtocol: 3,
-						client: {
-							id: "chat-relay",
-							displayName: "Alfe Chat Relay",
-							version: "1.0.0",
-							platform: process.platform,
-							mode: "backend",
-							instanceId: `chat-${Date.now().toString(36)}`
-						},
-						caps: [],
-						role: "operator",
-						scopes: ["operator.admin"],
-						auth: this.token ? { token: this.token } : void 0
-					}
-				}));
-			});
-			this.connected = true;
-			this.log.info("Runtime authenticated — relay active");
-		} catch (err) {
-			const errMsg = err instanceof Error ? err.message : String(err);
-			this.log.error(`Runtime connect failed: ${errMsg}`);
-			this.ws?.close(1008, "connect failed");
-		}
-	}
-	handleMessage(raw) {
-		try {
-			const parsed = JSON.parse(raw);
-			if (parsed.event) {
-				const payload = parsed.payload;
-				if (parsed.event === "connect.challenge" && payload?.nonce) {
-					this.connectSent = false;
-					this.sendConnect();
-					return;
-				}
-				if (payload) this.options.onEvent(parsed.event, payload);
-				return;
-			}
-			if ("id" in parsed && "ok" in parsed) {
-				const pending = this.pending.get(parsed.id);
-				if (!pending) return;
-				const payload = parsed.payload;
-				if (pending.expectFinal && payload?.status === "accepted") return;
-				this.pending.delete(parsed.id);
-				if (parsed.ok) pending.resolve(payload);
-				else {
-					const error = parsed.error;
-					pending.reject(new Error(error?.message ?? "unknown error"));
-				}
-			}
-		} catch (err) {
-			const errMsg = err instanceof Error ? err.message : String(err);
-			this.log.error(`Runtime message parse error: ${errMsg}`);
-		}
-	}
-	scheduleReconnect() {
-		if (this.stopped) return;
-		const delay = RECONNECT_DELAYS[Math.min(this.retryCount, RECONNECT_DELAYS.length - 1)];
-		this.retryCount++;
-		this.connectSent = false;
-		this.log.info(`Reconnecting to runtime in ${String(delay)}ms (attempt ${String(this.retryCount)})...`);
-		this.retryTimer = setTimeout(() => {
-			this.retryTimer = null;
-			this.doConnect();
-		}, delay);
-	}
-	flushPending(err) {
-		for (const [, p] of this.pending) p.reject(err);
-		this.pending.clear();
-	}
-};
+/**
+* Check if a session key belongs to the Alfe chat channel.
+* Handles both raw and prefixed 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] ?? ""
+	};
+}
 //#endregion
 //#region src/session-store.ts
 /**
@@ -379,14 +175,53 @@ var RuntimeRelay = class {
 *
 * 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 = join(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 (!existsSync(SESSIONS_DIR)) await mkdir(SESSIONS_DIR, { recursive: true });
 }
 function sessionPath(sessionId) {
 	return 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 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 = join(SESSIONS_DIR, file);
+				if (now - (await stat(filePath)).mtimeMs > MAX_AGE_MS) await unlink(filePath);
+			} catch {}
+			return;
+		}
+		const fileStats = [];
+		for (const file of jsonFiles) try {
+			const filePath = join(SESSIONS_DIR, file);
+			const fileStat = await 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 unlink(entry.path);
+				remaining--;
+			} catch {}
+		}
+	} catch {}
+}
 async function getSession(sessionId) {
 	try {
 		const data = await readFile(sessionPath(sessionId), "utf-8");
@@ -413,6 +248,7 @@ async function createSession(sessionId, agentId, channel, tenantId, userId) {
 		messages: []
 	};
 	await saveSession(session);
+	cleanupOldSessions();
 	return session;
 }
 async function addMessage(sessionId, role, content) {
@@ -425,7 +261,7 @@ async function addMessage(sessionId, role, content) {
 	});
 	await saveSession(session);
 }
-async function listSessions(filters) {
+async function listSessions(filters, limit = 50) {
 	await ensureDir();
 	let files;
 	try {
@@ -456,62 +292,65 @@ async function listSessions(filters) {
 		const aTime = a.lastMessageAt ?? a.createdAt;
 		return (b.lastMessageAt ?? b.createdAt).localeCompare(aTime);
 	});
-	return summaries;
+	return summaries.slice(0, limit);
 }
 //#endregion
 //#region src/plugin.ts
 /**
 * @alfe.ai/openclaw-chat — OpenClaw chat channel plugin.
 *
-* Registers the 'alfe' channel with OpenClaw, creating a first-class
-* channel for Alfe conversations. Web and mobile clients share the
-* same channel and conversation sessions.
+* Registers the 'alfe' channel with OpenClaw. Messages are dispatched
+* in-process via runtime.subagent.run() — no separate WebSocket to the
+* runtime needed.
 *
-* This follows the same pattern as the voice-gateway plugin:
-*   - Registers channel via api.registerChannel()
-*   - Connects to the Alfe daemon IPC for capability registration
-*   - Registers gateway RPC methods for message delivery and session queries
-*   - Hooks into session lifecycle events
-*   - Persists chat sessions to ~/.alfe/sessions/chat/
-*   - Gracefully degrades if the daemon is unavailable
+* Architecture:
+*   Chat Service (Fly.io) ←WS→ ChatServiceClient → runtime.subagent.run() → Agent (in-process)
+*                               ← onAgentEvent streaming ←
 */
-const DEFAULT_SOCKET_PATH = join(homedir(), ".alfe", "gateway.sock");
-const CHAT_CAPABILITIES = [
-	"chat.web",
-	"chat.mobile",
-	"chat.sessions"
-];
-let daemonIpcClient = null;
+let pluginRuntime = null;
 let chatClient = null;
-let runtimeRelay = null;
-/**
-* Attempt to connect to the Alfe daemon IPC socket.
-* Returns null if @alfe.ai/openclaw is not available or daemon is unreachable.
-*/
-async function connectToDaemon(socketPath, log) {
+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" });
+		return;
+	}
+	const unsubscribe = runtime.events.onAgentEvent((evt) => {
+		if (evt.sessionKey !== sessionKey) return;
+		if (evt.stream === "assistant") chatClient?.sendEvent("chat", {
+			runId: evt.runId,
+			sessionKey,
+			seq: evt.seq,
+			state: "delta",
+			message: evt.data
+		});
+	});
 	try {
-		const IPCClientCtor = (await import("@alfe.ai/openclaw")).IPCClient;
-		const client = new IPCClientCtor(socketPath, log);
-		client.on("connected", async () => {
-			log.info("Connected to Alfe daemon — registering chat capabilities...");
-			const response = await client.request("capability.register", {
-				plugin: "@alfe.ai/openclaw-chat",
-				capabilities: [...CHAT_CAPABILITIES]
-			});
-			if (response.ok) log.info("Chat capabilities registered with daemon");
-			else log.warn(`Failed to register chat capabilities: ${response.error?.message ?? "unknown"}`);
+		const { runId } = await runtime.subagent.run({
+			sessionKey,
+			message,
+			deliver: true
 		});
-		client.on("disconnected", (reason) => {
-			log.warn(`Disconnected from Alfe daemon: ${String(reason)}`);
+		const result = await runtime.subagent.waitForRun({
+			runId,
+			timeoutMs: 12e4
 		});
-		client.on("error", (err) => {
-			log.debug(`Daemon IPC error: ${err.message}`);
+		if (result.status === "ok") chatClient?.sendResponse(request.id, true, {
+			text: "",
+			sessionKey
 		});
-		client.start();
-		return client;
-	} catch {
-		log.info("Alfe daemon not available — chat plugin running standalone");
-		return null;
+		else chatClient?.sendResponse(request.id, false, { message: result.error ?? `Agent run ${result.status}` });
+	} 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();
 	}
 }
 const plugin = {
@@ -519,80 +358,56 @@ const plugin = {
 	name: "Alfe Chat Plugin",
 	description: "Alfe conversation channel — web widget and mobile app share unified chat sessions",
 	version: "0.3.0",
-	async activate(api) {
+	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 activating...");
-		const pluginConfig = (api.config ?? {}).plugins?.entries?.["@alfe.ai/openclaw-chat"]?.config ?? {};
+		log.info("Alfe Chat plugin registering...");
 		const alfeChannel = createAlfeChannelPlugin();
 		api.registerChannel(alfeChannel);
-		log.info(`Registered channel: ${alfeChannel.id} (${alfeChannel.meta.label})`);
-		daemonIpcClient = await connectToDaemon(pluginConfig.daemonSocket ?? process.env.ALFE_GATEWAY_SOCKET ?? DEFAULT_SOCKET_PATH, log);
-		const { apiKey, chatWsUrl } = await resolveAlfeChat({
-			apiKey: pluginConfig.apiKey,
-			chatWsUrl: pluginConfig.chatWsUrl
-		});
-		const runtimeUrl = pluginConfig.openclawGatewayUrl ?? process.env.OPENCLAW_GATEWAY_URL ?? "ws://127.0.0.1:18789";
-		const runtimeToken = process.env.OPENCLAW_GATEWAY_TOKEN ?? "";
-		if (chatWsUrl && apiKey) {
-			log.info(`Connecting to chat service: ${chatWsUrl}`);
-			runtimeRelay = new RuntimeRelay({
-				wsUrl: runtimeUrl,
-				token: runtimeToken,
-				onEvent: (event, payload) => {
-					chatClient?.sendEvent(event, payload);
-				},
-				logger: log
-			});
-			chatClient = new ChatServiceClient({
-				wsUrl: chatWsUrl,
-				apiKey,
-				onRequest: (request) => {
-					if (!runtimeRelay?.isConnected) {
-						chatClient?.sendResponse(request.id, false, { message: "Runtime not connected" });
-						return;
-					}
-					runtimeRelay.forwardRequest(request, (response) => {
-						chatClient?.send(response);
+		log.info(`Registered channel: ${alfeChannel.id}`);
+		const pluginConfig = (((api.config ?? {}).plugins?.entries)?.["@alfe.ai/openclaw-chat"] ?? {}).config ?? {};
+		(async () => {
+			try {
+				const { apiKey, chatWsUrl } = await resolveAlfeChat({
+					apiKey: pluginConfig.apiKey,
+					chatWsUrl: pluginConfig.chatWsUrl
+				});
+				if (chatWsUrl && apiKey) {
+					log.info(`Connecting to chat service: ${chatWsUrl}`);
+					chatClient = new ChatServiceClient({
+						wsUrl: chatWsUrl,
+						apiKey,
+						onRequest: (request) => {
+							if (request.method === "agent") handleAgentRequest(request, log);
+						},
+						onConnectionChange: (connected) => {
+							log.info(`Chat service connection: ${connected ? "connected" : "disconnected"}`);
+						},
+						logger: log
 					});
-				},
-				onConnectionChange: (connected) => {
-					log.info(`Chat service connection: ${connected ? "connected" : "disconnected"}`);
-				},
-				logger: log
-			});
-			runtimeRelay.start();
-			chatClient.start();
-			log.info("Chat service relay started");
-		} else log.info("Chat service URL not configured — running without chat service relay");
+					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("chat.send", (...args) => {
-				const { sessionId, content, clientType } = args[0];
-				log.info(`chat.send RPC: session=${sessionId}, client=${clientType ?? "unknown"}, content=${content.slice(0, 50)}...`);
-				return Promise.resolve({
-					ok: true,
-					sessionId,
-					channel: "alfe"
-				});
-			});
-			log.info("Registered gateway RPC method: chat.send");
 			api.registerGatewayMethod("sessions.list", async (...args) => {
 				const params = args[0];
-				log.info(`sessions.list RPC: agentId=${params.agentId ?? "*"}, channel=${params.channel ?? "*"}`);
 				return { sessions: await listSessions({
 					agentId: params.agentId,
 					channel: params.channel,
 					tenantId: params.tenantId
 				}) };
 			});
-			log.info("Registered gateway RPC method: sessions.list");
 			api.registerGatewayMethod("sessions.get", async (...args) => {
 				const params = args[0];
-				log.info(`sessions.get RPC: sessionId=${params.sessionId}`);
 				const session = await getSession(params.sessionId);
 				if (!session) return {
 					ok: false,
@@ -611,30 +426,27 @@ const plugin = {
 					}))
 				};
 			});
-			log.info("Registered gateway RPC method: sessions.get");
+			log.info("Registered gateway RPC methods: sessions.list, sessions.get");
 		}
 		api.on("session_start", async (...eventArgs) => {
 			const key = eventArgs[0].sessionKey;
-			if (!key) return;
-			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) return;
+			if (!key || !isAlfeSessionKey(key)) return;
 			log.info(`Alfe chat session starting: ${key}`);
-			const parts = key.split("-");
-			await createSession(key, parts.length >= 3 ? parts[2] : "", "alfe", parts.length >= 2 ? parts[1] : "");
+			const { tenantId, agentId: parsedAgentId } = parseAlfeSessionKey(key);
+			await createSession(key, parsedAgentId, "alfe", tenantId);
 		}, { priority: 50 });
 		api.on("message", async (...eventArgs) => {
 			const event = eventArgs[0];
 			const key = event.sessionKey;
-			if (!key) return;
-			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) return;
+			if (!key || !isAlfeSessionKey(key)) return;
 			await addMessage(key, event.role, event.content);
 		});
 		api.on("session_end", (...eventArgs) => {
 			const key = eventArgs[0].sessionKey;
-			if (!key) return;
-			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) return;
+			if (!key || !isAlfeSessionKey(key)) return;
 			log.info(`Alfe chat session ending: ${key}`);
 		});
-		log.info("Alfe Chat plugin activated");
+		log.info("Alfe Chat plugin registered");
 	},
 	deactivate(api) {
 		globalThis.__alfeChatPluginActivated = false;
@@ -645,20 +457,7 @@ const plugin = {
 			chatClient = null;
 			log.info("Chat service client stopped");
 		}
-		if (runtimeRelay) {
-			runtimeRelay.stop();
-			runtimeRelay = null;
-			log.info("Runtime relay stopped");
-		}
-		if (daemonIpcClient) {
-			try {
-				daemonIpcClient.stop();
-				log.info("Disconnected from Alfe daemon");
-			} catch (err) {
-				log.debug(`Error disconnecting from daemon: ${err.message}`);
-			}
-			daemonIpcClient = null;
-		}
+		pluginRuntime = null;
 		log.info("Alfe Chat plugin deactivated");
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/openclaw-chat",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
   "type": "module",
   "main": "./dist/plugin.js",
@@ -25,12 +25,8 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "ws": "^8.18.0",
     "@alfe.ai/chat": "^0.0.2"
   },
-  "devDependencies": {
-    "@types/ws": "^8.5.13"
-  },
   "license": "UNLICENSED",
   "scripts": {
     "build": "tsdown",