@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/lifecycle/manager.d.ts

@@ -0,0 +1,12 @@
+import type { ImBotConfig } from "../contracts.js";
+import type { ImModuleDependencies } from "../ports.js";
+/** Serial updates replace only the target connection. */
+export declare class ImChannelManager {
+    #private;
+    readonly dependencies: ImModuleDependencies;
+    constructor(dependencies: ImModuleDependencies);
+    get status(): Record<string, unknown>[];
+    upsert(config: ImBotConfig): Promise<Record<string, unknown>>;
+    remove(id: string): Promise<void>;
+    close(): Promise<void>;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/lifecycle/manager.js

@@ -0,0 +1,73 @@
+import { ImRuntime } from "../application/im-channel.js";
+import { imBotIdentity, validateImConfig } from "./configuration.js";
+/** Serial updates replace only the target connection. */
+export class ImChannelManager {
+    dependencies;
+    #endpoints = new Map();
+    #queue = Promise.resolve();
+    #closed = false;
+    #closing;
+    #abort = new AbortController();
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    get status() {
+        return [...this.#endpoints.values()].map((runtime) => ({ ...runtime.status }));
+    }
+    upsert(config) {
+        const snapshot = structuredClone(config);
+        return this.#enqueue(async () => {
+            validateImConfig(snapshot);
+            const key = imBotIdentity(snapshot);
+            const current = this.#endpoints.get(key);
+            if (!current && this.#endpoints.size >= 16)
+                throw new Error("IM_ENDPOINT_CAPACITY_EXHAUSTED");
+            await current?.close();
+            if (this.#closed)
+                throw new Error("IM_MANAGER_CLOSED");
+            const runtime = new ImRuntime(snapshot, {
+                ...this.dependencies,
+                signal: AbortSignal.any([
+                    this.#abort.signal,
+                    ...(this.dependencies.signal ? [this.dependencies.signal] : [])
+                ])
+            });
+            this.#endpoints.set(key, runtime);
+            await runtime.start();
+            return { ...runtime.status };
+        });
+    }
+    remove(id) {
+        return this.#enqueue(async () => {
+            await this.#endpoints.get(id)?.close();
+            this.#endpoints.delete(id);
+        });
+    }
+    #enqueue(operation) {
+        const task = this.#queue.then(() => {
+            if (this.#closed)
+                throw new Error("IM_MANAGER_CLOSED");
+            return operation();
+        });
+        this.#queue = task.then(() => undefined, () => undefined);
+        return task;
+    }
+    close() {
+        if (this.#closing)
+            return this.#closing;
+        this.#closed = true;
+        // Cancel initialization before waiting for the queue it is blocking.
+        this.#abort.abort();
+        this.#closing = (async () => {
+            await this.#queue;
+            const results = await Promise.allSettled([...this.#endpoints.values()].map((runtime) => Promise.resolve().then(() => runtime.close())));
+            const errors = results
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (errors.length)
+                throw new AggregateError(errors, "IM_DISPOSE_FAILED");
+            this.#endpoints.clear();
+        })();
+        return this.#closing;
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/ports.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 宿主依赖入口：注入执行能力、凭据来源和脱敏诊断。
+ * SDK 应用自行决定账号目录和凭据生命周期，通道无需依赖 CLI 或具体 Provider。
+ */
+import type { ImBotConfig, ImExecutionPort } from "./contracts.js";
+import type { ImSessionStore } from "./application/session-store.js";
+import type { RuntimeLog, JsonObject } from "@mininglamp-oss/octo-runtime-daemon";
+import type { ContextItem } from "@mininglamp-oss/octo-runtime-protocol";
+export type ImCredentialSource = (config: ImBotConfig, signal: AbortSignal) => Promise<string | undefined>;
+export interface ImModuleDependencies {
+    prepareContexts?: (config: JsonObject, signal: AbortSignal) => Promise<ContextItem[]>;
+    log?: RuntimeLog;
+    host: ImExecutionPort;
+    /** Owning Extra/manager lifetime; aborts connections, execution and delivery. */
+    signal?: AbortSignal;
+    authorizeSpace?: (spaceId: string) => void;
+    credentials?: ImCredentialSource;
+    sessions?: ImSessionStore;
+    onDiagnostic?: (code: string, identity: {
+        endpointId: string;
+        runId?: string;
+    }) => void;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/ports.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/presentation/run-projector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 公开事件投影：将 CanonicalEvent 累积为平台无关的展示快照。
+ * 按消息/工具/模型轮次保留身份与顺序，仅公开协议允许的内容；不展示私有 reasoning。
+ */
+import type { CanonicalEvent, FailureEnvelope } from "@mininglamp-oss/octo-runtime-protocol";
+export interface ProgressItem {
+    id: string;
+    kind: "model_step" | "reasoning" | "commentary" | "tool";
+    status: string;
+    stepId?: string;
+    content: string;
+    toolName?: string;
+    summary?: string;
+    outcome?: "check_findings";
+    exitCode?: number;
+    finishReason?: string;
+    startedAtMs?: number;
+    durationMs?: number;
+}
+export interface RunPresentation {
+    runId: string;
+    seq: number;
+    phase: string;
+    label?: string;
+    terminal?: "completed" | "failed" | "cancelled";
+    elapsedMs?: number;
+    items: ProgressItem[];
+    reasoningCount: number;
+    toolCallCount: number;
+    modelStepCount: number;
+    failure?: FailureEnvelope;
+    resultUnknown?: boolean;
+}
+export declare class ImRunProjector {
+    #private;
+    readonly runId: string;
+    readonly allowToolPreview: boolean;
+    constructor(runId: string, allowToolPreview?: boolean);
+    accept(event: CanonicalEvent, now?: number): void;
+    get finalText(): string;
+    snapshot(now?: number): RunPresentation;
+}
+export declare function clampRunes(value: string, maximum: number): string;
+export declare function compactRunes(value: string, maximum: number): string;
+export declare function toolPreview(name: string, args: Record<string, unknown>): string;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/presentation/run-projector.js

@@ -0,0 +1,258 @@
+const publicExposures = new Set(["public_reasoning", "public_summary", "public_plan"]);
+export class ImRunProjector {
+    runId;
+    allowToolPreview;
+    #items = new Map();
+    #messages = new Map();
+    #toolInputs = new Map();
+    #currentStep;
+    #seq = 0;
+    #phase = "accepted";
+    #label;
+    #startedAt;
+    #endedAt;
+    #terminal;
+    #failure;
+    constructor(runId, allowToolPreview = false) {
+        this.runId = runId;
+        this.allowToolPreview = allowToolPreview;
+    }
+    accept(event, now = Date.now()) {
+        // 终态后不再接纳迟到帧，防止完成卡片被旧进度改回执行中。
+        if (this.#terminal)
+            return;
+        this.#seq++;
+        const p = event.payload;
+        // 实际协议以 activity/model_step 启动计时，不能只等待历史 run.started。
+        if (event.type === "activity.started" || event.type === "model_step.started")
+            this.#startedAt ??= now;
+        if (event.type === "run.started") {
+            this.#startedAt ??= now;
+            this.#phase = "model";
+            this.#label = undefined;
+        }
+        if (event.type === "run.queued")
+            this.#phase = "accepted";
+        if (event.type === "model_step.started") {
+            const p = event.payload;
+            this.#currentStep = p.stepId;
+            this.#item(`step:${p.stepId}`, "model_step", p.stepId).startedAtMs = p.startedAtMs;
+            this.#phase = "model";
+            this.#label = undefined;
+        }
+        if (event.type === "model_step.finished") {
+            const p = event.payload;
+            const item = this.#item(`step:${p.stepId}`, "model_step", p.stepId);
+            item.status = p.status;
+            item.finishReason = p.finishReason;
+            if (item.startedAtMs !== undefined && p.endedAtMs !== undefined)
+                item.durationMs = Math.max(0, p.endedAtMs - item.startedAtMs);
+        }
+        if (event.type.startsWith("message.")) {
+            const id = p.messageId ??
+                `unidentified:${p.stepId ?? this.#currentStep ?? "run"}:${p.channel ?? "final"}`;
+            const previous = this.#messages.get(id);
+            const channel = p.channel ?? previous?.channel ?? "final";
+            // analysis 必须显式声明可公开；历史片段也清除，避免后续快照泄漏。
+            if (channel === "analysis" && !publicExposures.has(p.exposure ?? "")) {
+                this.#messages.delete(id);
+                this.#items.delete(`message:${id}`);
+                return;
+            }
+            if (!["analysis", "commentary", "final"].includes(channel) ||
+                (p.role && p.role !== "assistant"))
+                return;
+            const text = typeof p.text !== "string"
+                ? (previous?.text ?? "")
+                : event.type === "message.delta"
+                    ? (previous?.text ?? "") + p.text
+                    : p.text;
+            const stepId = p.stepId ?? previous?.stepId ?? this.#currentStep;
+            this.#messages.set(id, { channel, text, stepId });
+            if (channel !== "final") {
+                const item = this.#item(`message:${id}`, channel === "analysis" ? "reasoning" : "commentary", stepId);
+                item.content = text;
+                item.status = event.type === "message.update" ? "completed" : "running";
+            }
+            if (channel === "final" && stepId && this.#items.has(`step:${stepId}`)) {
+                this.#items.get(`step:${stepId}`).content = [...this.#messages.values()]
+                    .filter((message) => message.channel === "final" && message.stepId === stepId)
+                    .map((message) => message.text)
+                    .join("\n\n");
+            }
+            this.#phase =
+                channel === "final" ? "answering" : channel === "analysis" ? "thinking" : "commentary";
+            this.#label = undefined;
+        }
+        if (event.type === "tool_call.create") {
+            const p = event.payload;
+            const item = this.#item(`tool:${p.id}`, "tool", p.stepId ?? this.#currentStep);
+            item.toolName = p.name;
+            item.startedAtMs = now;
+            if (this.allowToolPreview)
+                item.summary = toolPreview(p.name, p.args);
+            const command = stringArg(p.args.command ?? p.args.cmd);
+            if (command.length <= 8192)
+                this.#toolInputs.set(p.id, { command });
+            this.#phase = "tool";
+            this.#label = undefined;
+        }
+        if (event.type === "tool_call.update") {
+            const p = event.payload;
+            const item = this.#item(`tool:${p.id}`, "tool", p.stepId ?? this.#currentStep);
+            item.status = p.status;
+            item.exitCode = p.exitCode;
+            item.durationMs =
+                p.durationMs ??
+                    (item.startedAtMs === undefined ? undefined : Math.max(0, now - item.startedAtMs));
+            const input = this.#toolInputs.get(p.id);
+            if (p.status === "failed" && p.exitCode === 2 && input && detectorFindings(input, p.output))
+                item.outcome = "check_findings";
+            this.#toolInputs.delete(p.id);
+            this.#phase = "tool";
+            this.#label = "工具调用完成";
+        }
+        if (event.type === "activity.started") {
+            const p = event.payload;
+            const phases = {
+                thinking: "thinking",
+                executing_tool: "tool",
+                responding: "answering",
+                starting: "accepted",
+                waiting_input: "waiting",
+                waiting_approval: "waiting",
+                compacting: "model",
+                retrying: "model",
+                working: "model"
+            };
+            this.#phase = phases[p.kind] ?? "model";
+            this.#label = undefined;
+        }
+        if (event.type === "interaction.requested") {
+            this.#phase = "waiting";
+            this.#label = "等待你的确认或输入";
+        }
+        if (event.type === "interaction.resolved") {
+            this.#phase = "model";
+            this.#label = undefined;
+        }
+        if (event.type === "run.notice") {
+            const p = event.payload;
+            const labels = {
+                retry_scheduled: "正在重试",
+                context_compacted: "上下文已压缩",
+                model_rerouted: "已切换模型",
+                config_warning: "执行配置提示"
+            };
+            this.#label = labels[p.code];
+        }
+        if (event.type === "run.completed" ||
+            event.type === "run.failed" ||
+            event.type === "run.cancelled") {
+            this.#terminal =
+                event.type === "run.completed"
+                    ? "completed"
+                    : event.type === "run.failed"
+                        ? "failed"
+                        : "cancelled";
+            this.#endedAt = now;
+            this.#failure = p.failure;
+            for (const item of this.#items.values())
+                if (item.status === "running")
+                    item.status = this.#terminal === "completed" ? "completed" : "cancelled";
+        }
+        if (this.#items.size > 512 ||
+            this.#messages.size > 512 ||
+            [...this.#messages.values()].reduce((size, message) => size + Buffer.byteLength(message.text), 0) >
+                256 * 1024)
+            throw new Error("IM_RESULT_TOO_LARGE");
+    }
+    #item(id, kind, stepId) {
+        let item = this.#items.get(id);
+        if (!item) {
+            item = { id, kind, stepId, status: "running", content: "" };
+            this.#items.set(id, item);
+        }
+        return item;
+    }
+    get finalText() {
+        return [...this.#messages.values()]
+            .filter((m) => m.channel === "final")
+            .map((m) => m.text)
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    snapshot(now = Date.now()) {
+        const items = structuredClone([...this.#items.values()]);
+        return {
+            runId: this.runId,
+            seq: this.#seq,
+            phase: this.#phase,
+            label: this.#label,
+            terminal: this.#terminal,
+            elapsedMs: this.#startedAt === undefined
+                ? undefined
+                : Math.max(0, (this.#endedAt ?? now) - this.#startedAt),
+            items,
+            reasoningCount: items.filter((i) => i.kind === "reasoning").length,
+            toolCallCount: items.filter((i) => i.kind === "tool").length,
+            modelStepCount: items.filter((i) => i.kind === "model_step").length,
+            failure: this.#failure
+        };
+    }
+}
+export function clampRunes(value, maximum) {
+    const runes = Array.from(value);
+    return runes.length <= maximum ? value : runes.slice(0, Math.max(0, maximum - 1)).join("") + "…";
+}
+export function compactRunes(value, maximum) {
+    const runes = Array.from(value);
+    if (runes.length <= maximum)
+        return value;
+    const head = Math.floor(((maximum - 3) * 2) / 3);
+    return runes.slice(0, head).join("") + " … " + runes.slice(-(maximum - 3 - head)).join("");
+}
+export function toolPreview(name, args) {
+    const sensitive = /token|secret|password|passwd|credential|authorization|cookie|api_key|apikey|\.env|id_rsa|id_ed25519|private_key|sk-|bf_|ghp_|xoxb-/i;
+    if (["exec_command", "shell", "bash", "sh", "zsh"].includes(name.toLowerCase())) {
+        let command = stringArg(args.command ?? args.cmd).trim();
+        if (sensitive.test(command) || command.includes("\0"))
+            return "";
+        command = command.replace(/^(?:\S*\/)?(?:sh|bash|zsh|dash|ksh|fish)\s+-[a-z]*c[a-z]*\s+(['"])([\s\S]*)\1$/, "$2");
+        return clampRunes(command.replace(/\s+/g, " ").trim(), 42);
+    }
+    if (["read", "read_file", "write_file", "file_read", "file_write"].includes(name.toLowerCase())) {
+        const path = stringArg(args.path ?? args.file_path ?? args.filePath).replace(/\\/g, "/");
+        if (sensitive.test(path) || /:\/\/|[\r\n\0]/.test(path))
+            return "";
+        const parts = path
+            .split("/")
+            .filter((p) => p && p !== "." && p !== "..")
+            .slice(-2);
+        return parts.every((p) => /^[\p{L}\p{N}._+~ -]+$/u.test(p)) && parts.length
+            ? clampRunes("…/" + parts.join("/"), 96)
+            : "";
+    }
+    return "";
+}
+function detectorFindings(input, output) {
+    const command = stringArg(input.command ?? input.cmd);
+    if (!/\bdetect\b/.test(command) || !/--json\b/.test(command))
+        return false;
+    try {
+        const findings = typeof output === "string" ? JSON.parse(output) : output;
+        return (Array.isArray(findings) &&
+            findings.some((f) => {
+                if (!f || typeof f !== "object")
+                    return false;
+                const value = f.antipattern;
+                return typeof value === "string" && !!value.trim();
+            }));
+    }
+    catch {
+        return false;
+    }
+}
+function stringArg(value) {
+    return typeof value === "string" ? value : "";
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/transport/channel.d.ts

@@ -0,0 +1,21 @@
+import type { ChannelCallbacks, WecomBotConfig } from "../contracts.js";
+import type { ImCredentialSource } from "../ports.js";
+/** 企业微信 IM 平台连接器；不是 MCP。只处理平台准入、消息映射和 stream 回复。 */
+export declare class WecomTransport {
+    #private;
+    readonly config: WecomBotConfig;
+    readonly credentials: ImCredentialSource;
+    readonly callbacks: ChannelCallbacks;
+    readonly identity: string;
+    readonly botId: string;
+    constructor(config: WecomBotConfig, credentials: ImCredentialSource, callbacks: ChannelCallbacks);
+    get status(): {
+        connected: boolean;
+        authenticatedAt?: string;
+        heartbeatAcks?: number | undefined;
+        lastHeartbeatAt?: string;
+        error?: string;
+    };
+    start(signal: AbortSignal): Promise<void>;
+    close(): Promise<void>;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/transport/channel.js

@@ -0,0 +1,125 @@
+/**
+ * 企业微信平台适配：将授权文本映射为统一 IM 事件，并绑定原会话 stream 回复。
+ * 执行与会话策略复用公共编排；不注册 MCP 工具，也不继承客户 App 的聊天设置。
+ */
+import { CONTEXT_SCHEMA } from "@mininglamp-oss/octo-runtime-protocol";
+import { imBotIdentity } from "../lifecycle/configuration.js";
+import { WecomConnection } from "./connection.js";
+import { WecomStreamSession } from "./stream-session.js";
+/** 企业微信 IM 平台连接器；不是 MCP。只处理平台准入、消息映射和 stream 回复。 */
+export class WecomTransport {
+    config;
+    credentials;
+    callbacks;
+    identity;
+    botId;
+    #detachAbort;
+    #closing;
+    #connection;
+    #streams = new Set();
+    constructor(config, credentials, callbacks) {
+        this.config = config;
+        this.credentials = credentials;
+        this.callbacks = callbacks;
+        this.identity = imBotIdentity(config);
+        this.botId = config.bot_id;
+    }
+    get status() {
+        return { ...this.#connection?.status, connected: this.#connection?.status.connected ?? false };
+    }
+    async start(signal) {
+        const secret = await this.credentials(this.config, signal);
+        if (!secret)
+            throw new Error("IM_CREDENTIALS_REQUIRED");
+        if (signal.aborted)
+            return;
+        const connection = new WecomConnection({ wsUrl: this.config.ws_url }, {
+            onMessage: (frame) => this.#receive(frame, connection),
+            onDisconnect: (code) => this.callbacks.onDisconnect(code, code !== "WECOM_CONNECTION_REPLACED")
+        });
+        this.#connection = connection;
+        const abort = () => {
+            void connection.close();
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        this.#detachAbort = () => signal.removeEventListener("abort", abort);
+        if (signal.aborted)
+            return;
+        await connection.connect({ appBot: this.config.bot_id, appSecret: secret });
+        if (signal.aborted)
+            await connection.close();
+    }
+    #receive(frame, connection) {
+        const body = frame.body;
+        // 企业微信可见范围 / 会话权限是默认准入；用户白名单仅为宿主可选的进一步限制。
+        if (!body ||
+            body.aibotid !== this.config.bot_id ||
+            body.msgtype !== "text" ||
+            typeof body.msgid !== "string" ||
+            !body.msgid ||
+            typeof frame.headers?.req_id !== "string" ||
+            !frame.headers.req_id ||
+            typeof body.from?.userid !== "string" ||
+            !body.from.userid ||
+            typeof body.text?.content !== "string" ||
+            !["single", "group"].includes(body.chattype))
+            return;
+        const conversationId = body.chattype === "single" ? body.from.userid : body.chatid;
+        if (!conversationId || typeof conversationId !== "string")
+            return;
+        const stream = new WecomStreamSession((streamId, text, finish) => connection.replyStream(frame.headers.req_id, streamId, fitReply(text), finish));
+        this.callbacks.onMessage({
+            messageId: body.msgid,
+            senderId: body.from.userid,
+            conversationId,
+            conversationKind: body.chattype === "single" ? "direct" : "group",
+            text: body.text.content,
+            buildContext: (_signal, options) => Promise.resolve({
+                schema: CONTEXT_SCHEMA,
+                items: structuredClone([
+                    ...(options?.configuredItems ?? this.config.context?.items ?? [])
+                ])
+            }),
+            beginPresentation: (_runId, onDiagnostic) => {
+                this.#streams.add(stream);
+                return stream.begin(onDiagnostic);
+            },
+            reply: (text, effectKey) => stream.reply(text, effectKey).finally(() => {
+                if (effectKey?.startsWith("final:"))
+                    this.#streams.delete(stream);
+            })
+        });
+    }
+    close() {
+        if (this.#closing)
+            return this.#closing;
+        this.#detachAbort?.();
+        this.#closing = Promise.resolve().then(async () => {
+            const results = await Promise.allSettled([
+                ...[...this.#streams].map((stream) => Promise.resolve().then(() => stream.close())),
+                Promise.resolve().then(() => this.#connection?.close())
+            ]);
+            const errors = results
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (errors.length)
+                throw new AggregateError(errors, "IM_TRANSPORT_DISPOSE_FAILED");
+            this.#streams.clear();
+        });
+        return this.#closing;
+    }
+}
+function fitReply(text) {
+    if (Buffer.byteLength(text) <= 20_480)
+        return text;
+    const suffix = "\n\n（回复超过企业微信长度上限，已截断。）";
+    const budget = 20_480 - Buffer.byteLength(suffix);
+    let bytes = 0, result = "";
+    for (const rune of text) {
+        bytes += Buffer.byteLength(rune);
+        if (bytes > budget)
+            break;
+        result += rune;
+    }
+    return result + suffix;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-wecom/dist/transport/connection.d.ts

@@ -0,0 +1,53 @@
+export interface WecomCredentials {
+    /** 企业微信智能机器人 Bot ID；协议字段为 bot_id。 */
+    appBot: string;
+    /** 企业微信智能机器人 Secret；协议字段为 secret。 */
+    appSecret: string;
+}
+export interface WecomConnectionOptions {
+    wsUrl?: string;
+    heartbeatIntervalMs?: number;
+    requestTimeoutMs?: number;
+}
+export interface WecomMessageFrame {
+    cmd: "aibot_msg_callback";
+    headers: {
+        req_id: string;
+    };
+    body: {
+        msgid: string;
+        aibotid: string;
+        chatid?: string;
+        chattype: "single" | "group";
+        from: {
+            userid: string;
+        };
+        msgtype: string;
+        text?: {
+            content: string;
+        };
+    };
+}
+export interface WecomConnectionCallbacks {
+    onMessage?(frame: WecomMessageFrame): void;
+    onDisconnect?(code: string): void;
+}
+export interface WecomConnectionStatus {
+    connected: boolean;
+    authenticatedAt?: string;
+    heartbeatAcks: number;
+    lastHeartbeatAt?: string;
+    error?: string;
+}
+/** 企业微信 IM 传输：鉴权、心跳、消息回调和回复；不是 MCP 连接器，不发起 AgentRun。 */
+export declare class WecomConnection {
+    #private;
+    readonly callbacks: WecomConnectionCallbacks;
+    constructor(options?: WecomConnectionOptions, callbacks?: WecomConnectionCallbacks);
+    get status(): WecomConnectionStatus;
+    connect(credentials: WecomCredentials): Promise<void>;
+    /** 只有 req_id 匹配且 errcode=0 的服务端回执才计为心跳成功。 */
+    ping(): Promise<void>;
+    replyStream(reqId: string, streamId: string, content: string, finish: boolean): Promise<void>;
+    close(): Promise<void>;
+}