@alfe.ai/openclaw-chat 0.0.3 → 0.0.5

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
 
@@ -36,4 +36,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,68 @@ 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>;
   };
-  plugins?: {
-    entries?: Record<string, {
-      config?: AlfePluginConfig;
-      [key: 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;
     }>;
-    [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>;
   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;
+  /**
+   * Called by OpenClaw to inject the in-process runtime.
+   * This replaces the need for a separate WS connection.
+   */
+  setRuntime(runtime: PluginRuntime): 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, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { ChatServiceClient } 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,239 +135,6 @@ function createAlfeChannelPlugin() {
 	};
 }
 //#endregion
-//#region src/runtime-relay.ts
-/**
-* RuntimeRelay — bridges the chat service to the local OpenClaw runtime.
-*
-* 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.
-*
-* Modeled after the voice relay's LocalGatewayClient pattern.
-*/
-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();
-	}
-};
-//#endregion
 //#region src/session-store.ts
 /**
 * Session Store — persists chat sessions to the local filesystem.
@@ -463,55 +228,58 @@ async function listSessions(filters) {
 /**
 * @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,78 +287,58 @@ 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) {
+	setRuntime(runtime) {
+		pluginRuntime = runtime;
+	},
+	activate(api) {
 		if (globalThis.__alfeChatPluginActivated) {
 			api.logger.debug("Alfe Chat plugin already activated, skipping re-init");
 			return;
 		}
 		globalThis.__alfeChatPluginActivated = true;
 		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 chatWsUrl = pluginConfig.chatWsUrl ?? process.env.ALFE_CHAT_WS_URL;
-		const apiKey = pluginConfig.apiKey ?? process.env.ALFE_API_KEY;
-		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,
@@ -609,7 +357,7 @@ 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;
@@ -632,7 +380,7 @@ const plugin = {
 			if (!(key.startsWith("chat-") || key.includes("alfe:") || key.includes(":alfe:"))) 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;
@@ -643,20 +391,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.3",
+  "version": "0.0.5",
   "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
   "type": "module",
   "main": "./dist/plugin.js",
@@ -25,11 +25,7 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "ws": "^8.18.0",
-    "@alfe.ai/chat": "^0.0.1"
-  },
-  "devDependencies": {
-    "@types/ws": "^8.5.13"
+    "@alfe.ai/chat": "^0.0.2"
   },
   "license": "UNLICENSED",
   "scripts": {