openclaw-stepfun 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenClaw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# OpenClaw Stepfun Plugin
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://img.shields.io/npm/v/openclaw-stepfun.svg)](https://www.npmjs.com/package/openclaw-stepfun)
+
+OpenClaw Stepfun WebSocket Gateway Channel Plugin - 将阶跃星辰 Stepfun Bot API 集成到 OpenClaw 平台。
+
+## 功能特性
+
+- 🤖 支持 Stepfun Bot API 双向通信
+- 🔄 自动重连和心跳保活
+- 📡 WebSocket 实时消息推送
+
+## 安装
+
+```bash
+openclaw plugins install openclaw-stepfun
+```
+
+验证安装：
+
+```bash
+openclaw plugins list
+```
+
+### 配置插件
+
+打开 OpenClaw Web UI（默认地址：http://127.0.0.1:18789）：
+
+1. 进入 **Channels** 页面
+2. 找到 **Stepfun Channels**
+3. 填写 **App ID** 和 **App Token**
+4. 点击 **Save** 保存配置
+
+## 更新
+
+更新插件到最新版本：
+
+```bash
+openclaw plugins update openclaw-stepfun
+```
+
+更新完成后重启网关：
+
+```bash
+openclaw gateway restart
+```
+
+## 环境要求
+
+- OpenClaw >= 2026.2.0
+- Node.js >= 18.0.0
+
+## 许可证
+
+[MIT](LICENSE)
+
+## 相关链接
+
+- [OpenClaw 官方文档](https://docs.openclaw.com)
+- [Stepfun 开放平台](https://platform.stepfun.com)

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export { monitorStepfunProvider } from "./src/monitor.js";
+export { sendMessageStepfun } from "./src/send.js";
+export { stepfunPlugin } from "./src/channel.js";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: unknown;
+    register: (api: OpenClawPluginApi) => void;
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,18 @@
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { stepfunPlugin } from "./src/channel.js";
+import { setStepfunRuntime } from "./src/runtime.js";
+export { monitorStepfunProvider } from "./src/monitor.js";
+export { sendMessageStepfun } from "./src/send.js";
+export { stepfunPlugin } from "./src/channel.js";
+const plugin = {
+    id: "openclaw-stepfun",
+    name: "OpenClaw Stepfun",
+    description: "Stepfun WebSocket gateway channel plugin",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setStepfunRuntime(api.runtime);
+        api.registerChannel({ plugin: stepfunPlugin });
+    },
+};
+export default plugin;
+//# sourceMappingURL=index.js.map

package/dist/src/accounts.d.ts

@@ -0,0 +1,22 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { ResolvedStepfunAccount } from "./types.js";
+/**
+ * Resolve Stepfun account configuration.
+ */
+export declare function resolveStepfunAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+}): ResolvedStepfunAccount;
+/**
+ * List all Stepfun account IDs.
+ */
+export declare function listStepfunAccountIds(cfg: OpenClawConfig): string[];
+/**
+ * List enabled Stepfun accounts.
+ */
+export declare function listEnabledStepfunAccounts(cfg: OpenClawConfig): ResolvedStepfunAccount[];
+/**
+ * Resolve default Stepfun account ID.
+ */
+export declare function resolveDefaultStepfunAccountId(_cfg: OpenClawConfig): string;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/src/accounts.js

@@ -0,0 +1,43 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+/**
+ * Resolve Stepfun account configuration.
+ */
+export function resolveStepfunAccount(params) {
+    const { cfg, accountId = DEFAULT_ACCOUNT_ID } = params;
+    const stepfunCfg = cfg.channels?.stepfun;
+    const enabled = stepfunCfg?.enabled ?? false;
+    // Account is configured if both appId and appToken are provided
+    const configured = Boolean(stepfunCfg?.appId && stepfunCfg?.appToken);
+    return {
+        accountId: accountId ?? DEFAULT_ACCOUNT_ID,
+        enabled,
+        configured,
+        config: stepfunCfg ?? {},
+    };
+}
+/**
+ * List all Stepfun account IDs.
+ */
+export function listStepfunAccountIds(cfg) {
+    const stepfunCfg = cfg.channels?.stepfun;
+    if (!stepfunCfg) {
+        return [];
+    }
+    return [DEFAULT_ACCOUNT_ID];
+}
+/**
+ * List enabled Stepfun accounts.
+ */
+export function listEnabledStepfunAccounts(cfg) {
+    const accountIds = listStepfunAccountIds(cfg);
+    return accountIds
+        .map((accountId) => resolveStepfunAccount({ cfg, accountId }))
+        .filter((account) => account.enabled && account.configured);
+}
+/**
+ * Resolve default Stepfun account ID.
+ */
+export function resolveDefaultStepfunAccountId(_cfg) {
+    return DEFAULT_ACCOUNT_ID;
+}
+//# sourceMappingURL=accounts.js.map

package/dist/src/bot.d.ts

@@ -0,0 +1,16 @@
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { StepfunInboundMessage, StepfunMessageContext } from "./types.js";
+/**
+ * Parse incoming message from Stepfun gateway.
+ */
+export declare function parseStepfunMessage(message: StepfunInboundMessage): StepfunMessageContext;
+/**
+ * Handle an inbound message from Stepfun gateway.
+ */
+export declare function handleStepfunMessage(params: {
+    cfg: OpenClawConfig;
+    message: StepfunInboundMessage;
+    runtime?: RuntimeEnv;
+    accountId?: string;
+}): Promise<void>;
+//# sourceMappingURL=bot.d.ts.map

package/dist/src/bot.js

@@ -0,0 +1,100 @@
+import { resolveStepfunAccount } from "./accounts.js";
+import { getStepfunRuntime } from "./runtime.js";
+import { createStepfunReplyDispatcher } from "./reply-dispatcher.js";
+/**
+ * Parse incoming message from Stepfun gateway.
+ */
+export function parseStepfunMessage(message) {
+    return {
+        chatSessionId: message.chatSessionId,
+        messageId: message.messageId,
+        userId: message.userId,
+        userName: message.userName,
+        content: message.content,
+    };
+}
+/**
+ * Handle an inbound message from Stepfun gateway.
+ */
+export async function handleStepfunMessage(params) {
+    const { cfg, message, runtime, accountId } = params;
+    const account = resolveStepfunAccount({ cfg, accountId });
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const ctx = parseStepfunMessage(message);
+    log(`stepfun[${account.accountId}]: received message from ${ctx.userId} in chat session ${ctx.chatSessionId}`);
+    try {
+        const core = getStepfunRuntime();
+        // Build identifiers for OpenClaw
+        const stepfunFrom = `stepfun:${ctx.userId}`;
+        const stepfunTo = `stepfun:${ctx.chatSessionId}`;
+        // Resolve agent route
+        const route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "stepfun",
+            accountId: account.accountId,
+            peer: {
+                kind: "direct",
+                id: `${ctx.chatSessionId}:${ctx.userId}`,
+            },
+        });
+        const preview = ctx.content.replace(/\s+/g, " ").slice(0, 160);
+        const inboundLabel = `Stepfun[${account.accountId}] message from ${ctx.userId}`;
+        core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
+            sessionKey: route.sessionKey,
+            contextKey: `stepfun:message:${ctx.chatSessionId}:${ctx.messageId}`,
+        });
+        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+        // Build message body with sender name
+        const speaker = ctx.userName ?? ctx.userId;
+        const messageBody = `${speaker}: ${ctx.content}`;
+        const body = core.channel.reply.formatAgentEnvelope({
+            channel: "Stepfun",
+            from: ctx.userId,
+            timestamp: new Date(),
+            envelope: envelopeOptions,
+            body: messageBody,
+        });
+        const ctxPayload = core.channel.reply.finalizeInboundContext({
+            Body: body,
+            RawBody: ctx.content,
+            CommandBody: ctx.content,
+            From: stepfunFrom,
+            To: stepfunTo,
+            SessionKey: route.sessionKey,
+            AccountId: route.accountId,
+            ChatType: "direct",
+            SenderName: ctx.userName ?? ctx.userId,
+            SenderId: ctx.userId,
+            Provider: "stepfun",
+            Surface: "stepfun",
+            MessageSid: ctx.messageId,
+            Timestamp: Date.now(),
+            WasMentioned: false,
+            CommandAuthorized: true,
+            OriginatingChannel: "stepfun",
+            OriginatingTo: stepfunTo,
+        });
+        // Create dispatcher that sends replies back to gateway
+        const agentId = route.agentId ?? "default";
+        const { dispatcher, replyOptions } = createStepfunReplyDispatcher({
+            cfg,
+            agentId,
+            runtime: { log, error },
+            chatSessionId: ctx.chatSessionId,
+            accountId: account.accountId,
+        });
+        log(`stepfun[${account.accountId}]: dispatching to agent (session=${route.sessionKey})`);
+        const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({
+            ctx: ctxPayload,
+            cfg,
+            dispatcher,
+            replyOptions,
+        });
+        log(`stepfun[${account.accountId}]: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
+    }
+    catch (err) {
+        error(`stepfun[${account.accountId}]: failed to dispatch message: ${String(err)}`);
+    }
+}
+//# sourceMappingURL=bot.js.map

package/dist/src/channel.d.ts

@@ -0,0 +1,4 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import type { ResolvedStepfunAccount } from "./types.js";
+export declare const stepfunPlugin: ChannelPlugin<ResolvedStepfunAccount>;
+//# sourceMappingURL=channel.d.ts.map

package/dist/src/channel.js

@@ -0,0 +1,206 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import { resolveStepfunAccount, listStepfunAccountIds, } from "./accounts.js";
+const meta = {
+    id: "openclaw-stepfun",
+    label: "Stepfun",
+    selectionLabel: "Stepfun Gateway",
+    docsPath: "/channels/openclaw-stepfun",
+    docsLabel: "openclaw-stepfun",
+    blurb: "Stepfun WebSocket gateway integration.",
+    aliases: [],
+    order: 80,
+};
+export const stepfunPlugin = {
+    id: "stepfun",
+    meta: {
+        ...meta,
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+        media: false,
+        reactions: false,
+        threads: false,
+        polls: false,
+        nativeCommands: false,
+        blockStreaming: false,
+    },
+    agentPrompt: {
+        messageToolHints: () => [
+            "- Stepfun: messages are automatically sent to the WebSocket gateway",
+            "- Conversation context is maintained per chatSessionId",
+        ],
+    },
+    reload: { configPrefixes: ["channels.stepfun"] },
+    configSchema: {
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    description: "Enable Stepfun channel",
+                    default: false,
+                },
+                appId: {
+                    type: "string",
+                    description: "App ID for bot authentication",
+                },
+                appToken: {
+                    type: "string",
+                    description: "App token for WebSocket connection authentication",
+                },
+            },
+        },
+    },
+    config: {
+        listAccountIds: (cfg) => listStepfunAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveStepfunAccount({ cfg, accountId }),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        setAccountEnabled: ({ cfg, accountId, enabled }) => {
+            const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+            if (isDefault) {
+                // Close WebSocket connection when disabling
+                if (!enabled) {
+                    import("./client.js")
+                        .then(({ closeStepfunWSClient }) => {
+                        closeStepfunWSClient();
+                    })
+                        .catch(() => {
+                        // Ignore import errors
+                    });
+                }
+                const stepfunConfig = cfg.channels?.stepfun ?? {};
+                return {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        stepfun: {
+                            ...stepfunConfig,
+                            enabled,
+                        },
+                    },
+                };
+            }
+            return cfg;
+        },
+        deleteAccount: ({ cfg, accountId }) => {
+            const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+            if (isDefault) {
+                const next = { ...cfg };
+                const nextChannels = { ...cfg.channels };
+                delete nextChannels.stepfun;
+                if (Object.keys(nextChannels).length > 0) {
+                    next.channels = nextChannels;
+                }
+                else {
+                    delete next.channels;
+                }
+                return next;
+            }
+            return cfg;
+        },
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            name: account.name,
+        }),
+    },
+    security: {
+        collectWarnings: () => [],
+    },
+    setup: {
+        resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+            if (isDefault) {
+                const stepfunConfig = (cfg.channels?.stepfun ?? {});
+                const setupInput = input;
+                return {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        stepfun: {
+                            ...stepfunConfig,
+                            enabled: true,
+                            ...(setupInput.appId ? { appId: setupInput.appId } : {}),
+                            ...(setupInput.appToken ? { appToken: setupInput.appToken } : {}),
+                        },
+                    },
+                };
+            }
+            return cfg;
+        },
+    },
+    messaging: {
+        normalizeTarget: (target) => target,
+        targetResolver: {
+            looksLikeId: (id) => typeof id === "string" && id.length > 0,
+            hint: "<chatSessionId>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async () => [],
+        listGroups: async () => [],
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+            port: null,
+        },
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+            port: null,
+        }),
+        probeAccount: async ({ account, timeoutMs, cfg }) => {
+            return {
+                ok: account.configured,
+                message: account.configured ? "Configured" : "Not configured",
+            };
+        },
+        buildAccountSnapshot: ({ account, runtime }) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            name: account.name,
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            port: null,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { monitorStepfunProvider } = await import("./monitor.js");
+            const account = resolveStepfunAccount({
+                cfg: ctx.cfg,
+                accountId: ctx.accountId,
+            });
+            ctx.setStatus({ accountId: ctx.accountId, port: null });
+            ctx.log?.info(`starting stepfun[${ctx.accountId}] (WebSocket gateway mode)`);
+            return monitorStepfunProvider({
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+                accountId: ctx.accountId,
+            });
+        },
+        stopAccount: async (ctx) => {
+            const { closeStepfunWSClient } = await import("./client.js");
+            ctx.log?.info(`stopping stepfun[${ctx.accountId}] (WebSocket gateway mode)`);
+            closeStepfunWSClient();
+        },
+    },
+};
+//# sourceMappingURL=channel.js.map

package/dist/src/client.d.ts

@@ -0,0 +1,51 @@
+import type { ResolvedStepfunAccount, StepfunOutboundMessage } from "./types.js";
+import { _Socket } from "./websocket/index.js";
+/**
+ * Wrapper class that adapts getSocket() to the StepfunWSClient interface.
+ * Maintains backward compatibility with existing code.
+ */
+declare class StepfunWSClientWrapper {
+    private socket;
+    private account;
+    private onMessage?;
+    private onError?;
+    private onClose?;
+    private isConnectedFlag;
+    constructor(socket: _Socket, account: ResolvedStepfunAccount);
+    private setupEventHandlers;
+    private convertToInboundMessage;
+    /**
+     * Connect to the gateway.
+     * Note: Errors are handled via onError callback, not thrown, to ensure
+     * the OpenClaw gateway is not affected by connection failures.
+     */
+    connect(handlers: {
+        onMessage?: (data: unknown) => void;
+        onError?: (error: Error) => void;
+        onClose?: () => void;
+    }): void;
+    /**
+     * Send a message to the gateway.
+     * Converts JSON message to Protobuf format.
+     */
+    send(data: StepfunOutboundMessage | Record<string, unknown>): Promise<void>;
+    /**
+     * Close the connection.
+     */
+    close(): void;
+    /**
+     * Check if connected.
+     */
+    isConnected(): boolean;
+}
+/**
+ * Get or create WebSocket client.
+ * If account config (appId or appToken) has changed, recreates the client with new credentials.
+ */
+export declare function getStepfunWSClient(account: ResolvedStepfunAccount): StepfunWSClientWrapper;
+/**
+ * Close and clear WebSocket client.
+ */
+export declare function closeStepfunWSClient(): void;
+export {};
+//# sourceMappingURL=client.d.ts.map