@hedgehog2026/ciwei-ai 1.0.2

package/index.ts

@@ -0,0 +1,25 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { ciweiAIPlugin } from "./src/channel";
+import { setCiweiAIRuntime } from "./src/runtime";
+
+/**
+ * ciweiAI
+ */
+const plugin: any = {
+  id: "ciweiAI",
+  name: "ciwei AI Channel",
+  description: "Custom WebSocket-based channel for Ciwei AI",
+  configSchema: emptyPluginConfigSchema(),
+
+  register(api: OpenClawPluginApi): void {
+    console.log("[ciweiAI] Registering plugin...");
+    setCiweiAIRuntime(api.runtime);
+
+    api.registerChannel({ plugin: ciweiAIPlugin });
+
+    // api.registerGatewayMethod("ciweiai.some.method", async (...) => { ... });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+    "id": "ciweiAI",
+    "name": "ciweiAI",
+    "version": "1.0.0",
+    "description": "Custom WebSocket-based channel plugin for Ciwei AI app",
+    "entry": "./index.ts",
+    "type": "channel",
+    "channels": [
+        "ciweiAI"
+    ],
+    "configSchema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {}
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@hedgehog2026/ciwei-ai",
+  "version": "1.0.2",
+  "description": "ciwei AI WebSocket channel for OpenClaw",
+  "keywords": [
+    "bot",
+    "channel",
+    "clawdbot",
+    "openclaw",
+    "stream",
+    "ciweiAI"
+  ],
+  "repository": "github:hedgehog2026/ciwei-ai",
+  "main": "index.ts",
+  "type": "module",
+  "author": "OpenClaw Community",
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.16.0",
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.2.13"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.3"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channels": [
+      "ciweiAI"
+    ],
+    "installDependencies": true,
+    "channel": {
+      "id": "ciweiAI",
+      "label": "ciwei AI",
+      "selectionLabel": "ciwei AI",
+      "docsPath": "/channels/ciweiai",
+      "blurb": "ciwei AI Custom Relay Channel.",
+      "order": 100
+    }
+  }
+}

package/src/channel.ts

@@ -0,0 +1,389 @@
+import { WebSocket } from "ws";
+import { z } from "zod";
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk";
+import {
+    ChannelPlugin,
+    OpenClawConfig,
+    ChannelGatewayContext,
+    ChannelAccountSnapshot,
+    ChannelStatusIssue
+} from "openclaw/plugin-sdk";
+import { getCiweiAIRuntime } from "./runtime";
+import type {
+    CiweiAIResolvedAccount,
+    RelayInboundMessage,
+    RelayReplyMessage
+} from "./types";
+
+
+/**
+ * Ciwei AI  Schema
+ *  accountId , token
+ */
+const CiweiAIConfigSchema = z.object({
+    token: z.string().describe("Relay server access token").optional(),
+    accountId: z.string().describe("Relay server account ID").optional(),
+});
+
+/**
+ * Unix
+ */
+function getCurrentTimestamp(): number {
+    return Date.now();
+}
+
+/**
+ * Ciwei AI Channel Plugin
+ * accountId + token
+ *
+ * "ciweiAI": {
+ *   "enabled": true,
+ *   "accountId": "13333333333",
+ *   "token": "your-token"
+ * }
+ */
+export const ciweiAIPlugin: ChannelPlugin<CiweiAIResolvedAccount> = {
+    id: "ciweiAI",
+
+    meta: {
+        id: "ciweiAI",
+        label: "Ciwei AI",
+        selectionLabel: "Ciwei AI",
+        blurb: "Custom WebSocket relay channel for Ciwei AI",
+        docsPath: "/channels/ciweiai",
+        order: 100,
+    },
+
+    configSchema: buildChannelConfigSchema(CiweiAIConfigSchema),
+
+    capabilities: {
+        chatTypes: ["direct"],
+        media: false,
+        reactions: false,
+        threads: false,
+        blockStreaming: true,
+    },
+
+    config: {
+        listAccountIds: (cfg: OpenClawConfig): string[] => {
+            const channelConfig = cfg.channels?.ciweiAI;
+            if (!channelConfig) return [];
+
+            if (channelConfig.accountId) {
+                return [channelConfig.accountId];
+            }
+
+            if (channelConfig.accounts) {
+                if (Array.isArray(channelConfig.accounts)) {
+                    return channelConfig.accounts.map((a: any) => a.accountId);
+                }
+                return Object.keys(channelConfig.accounts);
+            }
+
+            return ["default"];
+        },
+
+        resolveAccount: (cfg: OpenClawConfig, accountId?: string | null): CiweiAIResolvedAccount => {
+            const channelConfig = cfg.channels?.ciweiAI;
+
+            if (channelConfig?.accountId) {
+                const id = channelConfig.accountId;
+                const token = channelConfig.token;
+                return {
+                    accountId: id,
+                    config: { token },
+                    enabled: true,
+                    configured: Boolean(token),
+                };
+            }
+
+            const id = accountId || "default";
+            let accountInfo: any;
+
+            if (Array.isArray(channelConfig?.accounts)) {
+                accountInfo = channelConfig.accounts.find((a: any) => a.accountId === id);
+            } else {
+                accountInfo = channelConfig?.accounts?.[id];
+            }
+
+            let finalConfig: any = {};
+            if (typeof accountInfo === "string") {
+                finalConfig = { token: accountInfo };
+            } else if (accountInfo && typeof accountInfo === "object") {
+                finalConfig = accountInfo.config || accountInfo;
+            }
+
+            return {
+                accountId: id,
+                config: finalConfig,
+                enabled: accountInfo?.enabled !== false,
+                configured: Boolean(finalConfig.token),
+            };
+        },
+
+        defaultAccountId: (cfg: OpenClawConfig): string => {
+            const channelConfig = (cfg as any)?.channels?.ciweiAI;
+            return channelConfig?.accountId || "default";
+        },
+    },
+
+    gateway: {
+        startAccount: async (ctx: ChannelGatewayContext<CiweiAIResolvedAccount>) => {
+            const { account, cfg, log, abortSignal } = ctx;
+            const rt = getCiweiAIRuntime();
+            const accountId = String(account.accountId);
+            const token = account.config.token || "";
+            const relayUrl = `ws://47.110.64.126/relay?id=${accountId}&token=${token}&role=provider`;
+
+            let ws: WebSocket | null = null;
+            let isClosing = false;
+            let heartbeatInterval: NodeJS.Timeout | null = null;
+
+            // 用于阻塞 startAccount 的生命周期
+            let resolveStop: (value: void | PromiseLike<void>) => void;
+            const stopPromise = new Promise<void>((resolve) => {
+                resolveStop = resolve;
+            });
+
+            const stopClient = () => {
+                if (isClosing) return;
+                isClosing = true;
+
+                if (heartbeatInterval) clearInterval(heartbeatInterval);
+                log?.info?.(`[ciweiAI][${accountId}] Stopping gateway...`);
+
+                try {
+                    ws?.close();
+                } catch (err: any) {
+                    log?.warn?.(`[ciweiAI][${accountId}] Error during close: ${err.message}`);
+                }
+
+                ctx.setStatus({
+                    ...ctx.getStatus(),
+                    running: false,
+                    lastStopAt: getCurrentTimestamp(),
+                });
+
+                resolveStop();
+            };
+
+            const connect = () => {
+                if (isClosing) return;
+
+                log?.info?.(`[ciweiAI][${accountId}] Connecting to relay: ${relayUrl}`);
+                ws = new WebSocket(relayUrl);
+
+                ws.on("open", () => {
+                    log?.info?.(`[ciweiAI][${accountId}] Connected successfully.`);
+                    ctx.setStatus({
+                        ...ctx.getStatus(),
+                        running: true,
+                        lastStartAt: getCurrentTimestamp(),
+                        lastEventAt: getCurrentTimestamp(),
+                        lastError: null,
+                    });
+
+                    if (heartbeatInterval) clearInterval(heartbeatInterval);
+                    heartbeatInterval = setInterval(() => {
+                        if (ws?.readyState === WebSocket.OPEN) {
+                            ws.ping();
+                        }
+                    }, 30000);
+                });
+
+                const sentLengthMap: Record<string, number> = {};
+
+                ws.on("message", async (data) => {
+                    ctx.setStatus({
+                        ...ctx.getStatus(),
+                        lastEventAt: getCurrentTimestamp(),
+                    });
+
+                    try {
+                        const appPayload: RelayInboundMessage = JSON.parse(data.toString());
+                        const { from, text, chatId, id } = appPayload;
+
+                        if (!text) return;
+
+                        const context = rt.channel.reply.finalizeInboundContext({
+                            Body: text,
+                            From: from,
+                            To: chatId,
+                            SessionKey: `ws:${chatId}`,
+                            AccountId: String(accountId),
+                            Provider: "ciweiAI",
+                            MessageSid: id,
+                        });
+
+                        // Force streaming response as per OpenClaw docs
+                        const streamingCfg = JSON.parse(JSON.stringify(cfg));
+
+                        // 1. Enable block streaming for this specific channel
+                        streamingCfg.channels = streamingCfg.channels || {};
+                        streamingCfg.channels.ciweiAI = streamingCfg.channels.ciweiAI || {};
+                        streamingCfg.channels.ciweiAI.blockStreaming = true;
+                        // Also enable preview streaming as fallback
+                        streamingCfg.channels.ciweiAI.streaming = "block";
+
+                        // 2. Configure agents to emit chunks as they arrive instead of bundling
+                        streamingCfg.agents = streamingCfg.agents || {};
+                        streamingCfg.agents.defaults = streamingCfg.agents.defaults || {};
+                        streamingCfg.agents.defaults.blockStreamingDefault = "on";
+                        streamingCfg.agents.defaults.blockStreamingBreak = "text_end";
+
+                        await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                            ctx: context,
+                            cfg,
+                            dispatcherOptions: {
+                                deliver: async (payload: any) => {
+                                    if (ws?.readyState === WebSocket.OPEN) {
+                                        ws.send(JSON.stringify({
+                                            type: "reply",
+                                            to: from,
+                                            chatId: chatId,
+                                            replyTo: id,
+                                            isFinal: true
+                                        }));
+                                    }
+                                    delete sentLengthMap[chatId];
+                                }
+                            },
+                            replyOptions: {
+                                onPartialReply: (payload: any) => {
+                                    if (payload.text && ws?.readyState === WebSocket.OPEN) {
+                                        const prev = sentLengthMap[chatId] || 0;
+                                        const delta = payload.text.slice(prev);
+                                        sentLengthMap[chatId] = payload.text.length;
+                                        if (delta) {
+                                            ws.send(JSON.stringify({
+                                                type: "reply",
+                                                to: from,
+                                                chatId: chatId,
+                                                text: delta,
+                                                replyTo: id,
+                                                isPartial: true
+                                            }));
+                                        }
+                                    }
+                                },
+                                onReasoningStream: (payload: any) => {
+                                    if (payload.text && ws?.readyState === WebSocket.OPEN) {
+                                        const prev = sentLengthMap[chatId] || 0;
+                                        const delta = payload.text.slice(prev);
+                                        sentLengthMap[chatId] = payload.text.length;
+                                        if (delta) {
+                                            ws.send(JSON.stringify({
+                                                type: "reply",
+                                                to: from,
+                                                chatId: chatId,
+                                                text: delta,
+                                                replyTo: id,
+                                                isPartial: true
+                                            }));
+                                        }
+                                    }
+                                }
+                            }
+                        });
+                    } catch (err: any) {
+                        log?.error?.(`[ciweiAI][${accountId}] Dispatch error: ${err.message}`);
+                    }
+                });
+
+                ws.on("error", (err) => {
+                    log?.error?.(`[ciweiAI][${accountId}] WebSocket error: ${err.message}`);
+                    ctx.setStatus({
+                        ...ctx.getStatus(),
+                        lastError: `Connection error: ${err.message}`,
+                    });
+                });
+
+                ws.on("close", (code, reason) => {
+                    if (heartbeatInterval) clearInterval(heartbeatInterval);
+                    if (!isClosing) {
+                        log?.warn?.(`[ciweiAI][${accountId}] Connection dropped (code=${code}). Retrying in 5s...`);
+                        ctx.setStatus({
+                            ...ctx.getStatus(),
+                            running: false,
+                        });
+                        setTimeout(connect, 5000);
+                    }
+                });
+            };
+
+            connect();
+
+            abortSignal?.addEventListener("abort", () => {
+                log?.info?.(`[ciweiAI][${accountId}] Abort signal received`);
+                stopClient();
+            });
+
+            await stopPromise;
+
+            return {
+                stop: () => {
+                    stopClient();
+                },
+            };
+        }
+    },
+
+    status: {
+        defaultRuntime: {
+            accountId: "default",
+            running: false,
+            lastEventAt: null,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        collectStatusIssues: (accounts: ChannelAccountSnapshot[]): ChannelStatusIssue[] => {
+            return accounts.flatMap((account) => {
+                if (!account.configured) {
+                    return [
+                        {
+                            channel: "ciweiAI",
+                            accountId: account.accountId,
+                            kind: "config" as const,
+                            message: "Account not configured (missing relay token)",
+                        },
+                    ];
+                }
+                return [];
+            });
+        },
+        buildChannelSummary: ({ snapshot }: { snapshot: ChannelAccountSnapshot }) => ({
+            configured: snapshot?.configured ?? false,
+            running: snapshot?.running ?? false,
+            lastStartAt: snapshot?.lastStartAt ?? null,
+            lastStopAt: snapshot?.lastStopAt ?? null,
+            lastError: snapshot?.lastError ?? null,
+        }),
+        probeAccount: async ({ account }: { account: CiweiAIResolvedAccount }) => {
+            if (!account.configured || !account.config?.token) {
+                return { ok: false, error: "Token not configured" };
+            }
+            return { ok: true, details: { relay: "47.110.64.126" } };
+        },
+        buildAccountSnapshot: ({ account, runtime, snapshot, probe }: {
+            account: CiweiAIResolvedAccount,
+            runtime?: ChannelAccountSnapshot,
+            snapshot?: ChannelAccountSnapshot,
+            probe?: any
+        }): ChannelAccountSnapshot => {
+            const running = runtime?.running ?? snapshot?.running ?? false;
+            return {
+                ...snapshot,
+                accountId: account.accountId,
+                enabled: account.enabled,
+                configured: account.configured,
+                running,
+                lastEventAt: runtime?.lastEventAt ?? snapshot?.lastEventAt ?? null,
+                lastStartAt: runtime?.lastStartAt ?? snapshot?.lastStartAt ?? null,
+                lastStopAt: runtime?.lastStopAt ?? snapshot?.lastStopAt ?? null,
+                lastError: runtime?.lastError ?? snapshot?.lastError ?? null,
+                probe,
+            };
+        },
+    },
+};

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setCiweiAIRuntime(next: PluginRuntime): void {
+  runtime = next;
+}
+
+export function getCiweiAIRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("CiweiAI runtime not initialized");
+  }
+  return runtime;
+}

package/src/types.ts

@@ -0,0 +1,35 @@
+/**
+ * Ciwei AI
+ */
+export interface CiweiAIResolvedAccount {
+    accountId: string;
+    config: {
+        token?: string;
+    };
+    enabled: boolean;
+    configured: boolean;
+}
+
+/**
+ * Inbound
+ */
+export interface RelayInboundMessage {
+    type?: string;
+    from: string;
+    text: string;
+    chatId: string;
+    id: string;
+}
+
+/**
+ * Outbound
+ */
+export interface RelayReplyMessage {
+    type: "reply";
+    to: string;
+    chatId: string;
+    text: string;
+    replyTo: string;
+    isPartial?: boolean;
+    isFinal?: boolean;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "types": ["node"],
+    "paths": {
+      "openclaw/*": ["node_modules/openclaw/*"]
+    }
+  },
+  "include": ["index.ts", "src/**/*.ts"]
+}