@openclaw-china/qqbot 0.1.1

package/clawdbot.plugin.json

@@ -0,0 +1,25 @@
+{
+  "id": "qqbot",
+  "name": "QQ Bot",
+  "description": "QQ 开放平台机器人消息渠道插件",
+  "version": "0.1.0",
+  "channels": ["qqbot"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": { "type": "boolean" },
+      "appId": { "type": "string" },
+      "clientSecret": { "type": "string" },
+      "markdownSupport": { "type": "boolean" },
+      "dmPolicy": { "type": "string", "enum": ["open", "pairing", "allowlist"] },
+      "groupPolicy": { "type": "string", "enum": ["open", "allowlist", "disabled"] },
+      "requireMention": { "type": "boolean" },
+      "allowFrom": { "type": "array", "items": { "type": "string" } },
+      "groupAllowFrom": { "type": "array", "items": { "type": "string" } },
+      "historyLimit": { "type": "integer", "minimum": 0 },
+      "textChunkLimit": { "type": "integer", "minimum": 1 },
+      "replyFinalOnly": { "type": "boolean" }
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,438 @@
+import { z } from 'zod';
+
+declare const QQBotConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    appId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    markdownSupport: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["open", "pairing", "allowlist"]>>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["open", "allowlist", "disabled"]>>>;
+    requireMention: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    historyLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    textChunkLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    replyFinalOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    markdownSupport: boolean;
+    dmPolicy: "open" | "pairing" | "allowlist";
+    groupPolicy: "open" | "allowlist" | "disabled";
+    requireMention: boolean;
+    historyLimit: number;
+    textChunkLimit: number;
+    replyFinalOnly: boolean;
+    appId?: string | undefined;
+    clientSecret?: string | undefined;
+    allowFrom?: string[] | undefined;
+    groupAllowFrom?: string[] | undefined;
+}, {
+    enabled?: boolean | undefined;
+    appId?: string | undefined;
+    clientSecret?: string | undefined;
+    markdownSupport?: boolean | undefined;
+    dmPolicy?: "open" | "pairing" | "allowlist" | undefined;
+    groupPolicy?: "open" | "allowlist" | "disabled" | undefined;
+    requireMention?: boolean | undefined;
+    allowFrom?: string[] | undefined;
+    groupAllowFrom?: string[] | undefined;
+    historyLimit?: number | undefined;
+    textChunkLimit?: number | undefined;
+    replyFinalOnly?: boolean | undefined;
+}>;
+type QQBotConfig = z.infer<typeof QQBotConfigSchema>;
+
+interface ResolvedQQBotAccount {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    appId?: string;
+    markdownSupport?: boolean;
+}
+interface QQBotSendResult {
+    channel: "qqbot";
+    messageId?: string;
+    timestamp?: number | string;
+    error?: string;
+}
+
+/**
+ * QQ Bot 出站适配器（仅文本）
+ */
+
+interface OutboundConfig {
+    channels?: {
+        qqbot?: QQBotConfig;
+    };
+}
+
+declare const DEFAULT_ACCOUNT_ID = "default";
+interface PluginConfig {
+    channels?: {
+        qqbot?: QQBotConfig;
+    };
+}
+declare const qqbotPlugin: {
+    id: string;
+    meta: {
+        id: "qqbot";
+        label: "QQ Bot";
+        selectionLabel: "QQ Bot";
+        docsPath: "/channels/qqbot";
+        docsLabel: "qqbot";
+        blurb: "QQ 开放平台机器人消息";
+        aliases: readonly ["qq"];
+        order: 72;
+    };
+    capabilities: {
+        chatTypes: readonly ["direct", "channel"];
+        media: boolean;
+        reactions: boolean;
+        threads: boolean;
+        edit: boolean;
+        reply: boolean;
+        polls: boolean;
+        blockStreaming: boolean;
+    };
+    messaging: {
+        normalizeTarget: (raw: string) => string | undefined;
+        targetResolver: {
+            looksLikeId: (raw: string, normalized?: string) => boolean;
+            hint: string;
+        };
+        formatTargetDisplay: (params: {
+            target: string;
+            display?: string;
+            kind?: "user" | "group" | "channel";
+        }) => string;
+    };
+    configSchema: {
+        schema: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                enabled: {
+                    type: string;
+                };
+                appId: {
+                    type: string;
+                };
+                clientSecret: {
+                    type: string;
+                };
+                markdownSupport: {
+                    type: string;
+                };
+                dmPolicy: {
+                    type: string;
+                    enum: string[];
+                };
+                groupPolicy: {
+                    type: string;
+                    enum: string[];
+                };
+                requireMention: {
+                    type: string;
+                };
+                allowFrom: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                groupAllowFrom: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                historyLimit: {
+                    type: string;
+                    minimum: number;
+                };
+                textChunkLimit: {
+                    type: string;
+                    minimum: number;
+                };
+                replyFinalOnly: {
+                    type: string;
+                };
+            };
+        };
+    };
+    reload: {
+        configPrefixes: string[];
+    };
+    config: {
+        listAccountIds: (_cfg: PluginConfig) => string[];
+        resolveAccount: (cfg: PluginConfig, accountId?: string) => ResolvedQQBotAccount;
+        defaultAccountId: () => string;
+        setAccountEnabled: (params: {
+            cfg: PluginConfig;
+            enabled: boolean;
+        }) => PluginConfig;
+        deleteAccount: (params: {
+            cfg: PluginConfig;
+        }) => PluginConfig;
+        isConfigured: (_account: ResolvedQQBotAccount, cfg: PluginConfig) => boolean;
+        describeAccount: (account: ResolvedQQBotAccount) => {
+            accountId: string;
+            enabled: boolean;
+            configured: boolean;
+        };
+        resolveAllowFrom: (params: {
+            cfg: PluginConfig;
+        }) => string[];
+        formatAllowFrom: (params: {
+            allowFrom: (string | number)[];
+        }) => string[];
+    };
+    security: {
+        collectWarnings: (params: {
+            cfg: PluginConfig;
+        }) => string[];
+    };
+    setup: {
+        resolveAccountId: () => string;
+        applyAccountConfig: (params: {
+            cfg: PluginConfig;
+        }) => PluginConfig;
+    };
+    outbound: {
+        deliveryMode: "direct";
+        textChunkLimit: number;
+        chunkerMode: "markdown";
+        sendText: (params: {
+            cfg: OutboundConfig;
+            to: string;
+            text: string;
+            replyToId?: string;
+        }) => Promise<QQBotSendResult>;
+        sendMedia: (params: {
+            cfg: OutboundConfig;
+            to: string;
+            text?: string;
+            mediaUrl?: string;
+        }) => Promise<QQBotSendResult>;
+    };
+    gateway: {
+        startAccount: (ctx: {
+            cfg: PluginConfig;
+            runtime?: unknown;
+            abortSignal?: AbortSignal;
+            accountId: string;
+            setStatus?: (status: Record<string, unknown>) => void;
+            log?: {
+                info: (msg: string) => void;
+                error: (msg: string) => void;
+            };
+        }) => Promise<void>;
+        stopAccount: (_ctx: {
+            accountId: string;
+        }) => Promise<void>;
+        getStatus: () => {
+            connected: boolean;
+        };
+    };
+};
+
+interface PluginRuntime {
+    log?: (msg: string) => void;
+    error?: (msg: string) => void;
+    channel?: {
+        routing?: {
+            resolveAgentRoute?: (params: {
+                cfg: unknown;
+                channel: string;
+                accountId?: string;
+                peer: {
+                    kind: string;
+                    id: string;
+                };
+            }) => {
+                sessionKey: string;
+                accountId: string;
+                agentId?: string;
+            };
+        };
+        session?: {
+            resolveStorePath?: (store: unknown, params: {
+                agentId?: string;
+            }) => string | undefined;
+            readSessionUpdatedAt?: (params: {
+                storePath: string;
+                sessionKey: string;
+            }) => number | null;
+            recordSessionMetaFromInbound?: (params: {
+                storePath: string;
+                sessionKey: string;
+                ctx: unknown;
+                groupResolution?: unknown;
+                createIfMissing?: boolean;
+            }) => Promise<unknown>;
+            updateLastRoute?: (params: {
+                storePath: string;
+                sessionKey: string;
+                channel?: string;
+                to?: string;
+                accountId?: string;
+                threadId?: string | number;
+                deliveryContext?: unknown;
+                ctx?: unknown;
+                groupResolution?: unknown;
+            }) => Promise<unknown>;
+            recordInboundSession?: (params: {
+                storePath: string;
+                sessionKey: string;
+                ctx: unknown;
+                updateLastRoute?: {
+                    sessionKey: string;
+                    channel: string;
+                    to: string;
+                    accountId?: string;
+                    threadId?: string | number;
+                };
+                onRecordError?: (err: unknown) => void;
+            }) => Promise<void>;
+        };
+        reply?: {
+            dispatchReplyFromConfig?: (params: {
+                ctx: unknown;
+                cfg: unknown;
+                dispatcher?: unknown;
+                replyOptions?: unknown;
+            }) => Promise<{
+                queuedFinal: boolean;
+                counts: {
+                    final: number;
+                };
+            }>;
+            dispatchReplyWithBufferedBlockDispatcher?: (params: {
+                ctx: unknown;
+                cfg: unknown;
+                dispatcherOptions: {
+                    deliver: (payload: unknown, info?: {
+                        kind?: string;
+                    }) => Promise<void> | void;
+                    onError?: (err: unknown, info: {
+                        kind: string;
+                    }) => void;
+                    onSkip?: (payload: unknown, info: {
+                        kind: string;
+                        reason: string;
+                    }) => void;
+                    onReplyStart?: () => Promise<void> | void;
+                    humanDelay?: unknown;
+                };
+                replyOptions?: unknown;
+            }) => Promise<unknown>;
+            finalizeInboundContext?: (ctx: unknown) => unknown;
+            createReplyDispatcher?: (params: unknown) => unknown;
+            createReplyDispatcherWithTyping?: (params: unknown) => {
+                dispatcher: unknown;
+                replyOptions?: unknown;
+                markDispatchIdle?: () => void;
+            };
+            resolveHumanDelayConfig?: (cfg: unknown, agentId?: string) => unknown;
+            resolveEffectiveMessagesConfig?: (cfg: unknown) => unknown;
+            resolveEnvelopeFormatOptions?: (cfg: unknown) => unknown;
+            formatAgentEnvelope?: (params: unknown) => string;
+            formatInboundEnvelope?: (params: unknown) => string;
+        };
+        text?: {
+            resolveTextChunkLimit?: (params: {
+                cfg: unknown;
+                channel: string;
+                defaultLimit?: number;
+            }) => number;
+            resolveChunkMode?: (cfg: unknown, channel: string) => unknown;
+            resolveMarkdownTableMode?: (params: {
+                cfg: unknown;
+                channel: string;
+                accountId?: string;
+            }) => unknown;
+            convertMarkdownTables?: (text: string, mode: unknown) => string;
+            chunkTextWithMode?: (text: string, limit: number, mode: unknown) => string[];
+            chunkMarkdownText?: (text: string, limit: number) => string[];
+        };
+    };
+    system?: {
+        enqueueSystemEvent?: (message: string, options?: unknown) => void;
+    };
+    [key: string]: unknown;
+}
+declare function setQQBotRuntime(next: PluginRuntime): void;
+declare function getQQBotRuntime(): PluginRuntime;
+
+/**
+ * @openclaw-china/qqbot
+ * QQ Bot 渠道插件入口
+ */
+interface MoltbotPluginApi {
+    registerChannel: (opts: {
+        plugin: unknown;
+    }) => void;
+    runtime?: unknown;
+    [key: string]: unknown;
+}
+
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            enabled: {
+                type: string;
+            };
+            appId: {
+                type: string;
+            };
+            clientSecret: {
+                type: string;
+            };
+            markdownSupport: {
+                type: string;
+            };
+            dmPolicy: {
+                type: string;
+                enum: string[];
+            };
+            groupPolicy: {
+                type: string;
+                enum: string[];
+            };
+            requireMention: {
+                type: string;
+            };
+            allowFrom: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            groupAllowFrom: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            historyLimit: {
+                type: string;
+                minimum: number;
+            };
+            textChunkLimit: {
+                type: string;
+                minimum: number;
+            };
+            replyFinalOnly: {
+                type: string;
+            };
+        };
+    };
+    register(api: MoltbotPluginApi): void;
+};
+
+export { DEFAULT_ACCOUNT_ID, type MoltbotPluginApi, type QQBotConfig, type QQBotSendResult, type ResolvedQQBotAccount, plugin as default, getQQBotRuntime, qqbotPlugin, setQQBotRuntime };