@meet-im/meet 2.0.5 → 3.0.0-beta.0

package/dist/src/channel.js

@@ -0,0 +1,402 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, } from "openclaw/plugin-sdk/account-id";
+import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
+import { resolveMeetAccount, listMeetAccountIds, resolveDefaultMeetAccountId, isFlatAccountConfig, getFlatAccountKey, } from "./accounts.js";
+import { meetOutbound } from "./outbound.js";
+import { parseMeetTarget, looksLikeMeetId, formatMeetTarget, } from "./targets.js";
+import { sendMessageMeet } from "./send.js";
+const meta = {
+    id: "meet",
+    label: "Meet",
+    selectionLabel: "Meet IM",
+    docsPath: "/channels/meet",
+    docsLabel: "meet",
+    blurb: "Meet IM platform integration.",
+    aliases: [],
+    order: 80,
+};
+export const meetPlugin = {
+    id: "meet",
+    meta: {
+        ...meta,
+    },
+    pairing: {
+        idLabel: "meetUserId",
+        normalizeAllowEntry: (entry) => entry.replace(/^(meet|user):/i, ""),
+        notifyApproval: async ({ cfg, id }) => {
+            await sendMessageMeet({
+                cfg,
+                to: id,
+                text: PAIRING_APPROVED_MESSAGE,
+            });
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "channel"],
+        polls: false,
+        threads: false,
+        media: true,
+        reactions: false,
+        edit: false,
+        reply: false,
+    },
+    agentPrompt: {
+        messageToolHints: () => [
+            "- Meet targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:<id>` or `channel:<id>`.",
+            "- Meet mentions: use `<@USER_ID>` to mention users, `<@-1>` to mention everyone. Examples: `<@553> hello` or `<@-1> important announcement`.",
+            "- Meet media: use `media` parameter to send images/files as attachments. DO NOT use Markdown image syntax like `![](path)` - Meet does not render it.",
+        ],
+    },
+    groups: {
+        resolveToolPolicy: ({ cfg: _cfg, accountId: _accountId, groupId: _groupId, }) => {
+            // 群组访问控制在 bot.ts 中处理，这里只返回工具策略配置
+            // 不使用 { deny: ["*"] } 拒绝所有工具，否则会导致 tools: []
+            return undefined;
+        },
+    },
+    reload: { configPrefixes: ["channels.meet"] },
+    configSchema: {
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                enabled: { type: "boolean" },
+                defaultAccount: { type: "string" },
+                apiEndpoint: { type: "string" },
+                apiToken: { type: "string" },
+                pollTimeout: { type: "integer", minimum: 1000, maximum: 300000 },
+                pollLimit: { type: "integer", minimum: 1, maximum: 1000 },
+                dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+                allowFrom: {
+                    type: "array",
+                    items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                },
+                groupPolicy: {
+                    type: "string",
+                    enum: ["open", "allowlist", "disabled"],
+                },
+                groupAllowFrom: {
+                    type: "array",
+                    items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                },
+                groups: {
+                    type: "object",
+                    additionalProperties: {
+                        type: "object",
+                        properties: {
+                            enabled: { type: "boolean" },
+                            name: { type: "string" },
+                            requireMention: { type: "boolean" },
+                            systemPrompt: { type: "string" },
+                            users: {
+                                type: "array",
+                                items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                            },
+                        },
+                    },
+                },
+                requireMention: { type: "boolean" },
+                historyLimit: { type: "integer", minimum: 0 },
+                dmHistoryLimit: { type: "integer", minimum: 0 },
+                textChunkLimit: { type: "integer", minimum: 1 },
+                mediaMaxMb: { type: "number", minimum: 0 },
+                accounts: {
+                    type: "object",
+                    additionalProperties: {
+                        type: "object",
+                        properties: {
+                            enabled: { type: "boolean" },
+                            name: { type: "string" },
+                            apiEndpoint: { type: "string" },
+                            token: { type: "string" },
+                            apiToken: { type: "string" },
+                            pollTimeout: { type: "integer", minimum: 1000, maximum: 300000 },
+                            pollLimit: { type: "integer", minimum: 1, maximum: 1000 },
+                            logLevel: { type: "string", enum: ["silent", "info"] },
+                            dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+                            allowFrom: {
+                                type: "array",
+                                items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                            },
+                            groupPolicy: {
+                                type: "string",
+                                enum: ["open", "allowlist", "disabled"],
+                            },
+                            groupAllowFrom: {
+                                type: "array",
+                                items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                            },
+                            requireMention: { type: "boolean" },
+                            systemPrompt: { type: "string" },
+                            historyLimit: { type: "integer", minimum: 0 },
+                            dmHistoryLimit: { type: "integer", minimum: 0 },
+                            textChunkLimit: { type: "integer", minimum: 1 },
+                            mediaMaxMb: { type: "number", minimum: 0 },
+                            groups: {
+                                type: "object",
+                                additionalProperties: {
+                                    type: "object",
+                                    properties: {
+                                        enabled: { type: "boolean" },
+                                        name: { type: "string" },
+                                        requireMention: { type: "boolean" },
+                                        systemPrompt: { type: "string" },
+                                        users: {
+                                            type: "array",
+                                            items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                                        },
+                                        groupPolicy: {
+                                            type: "string",
+                                            enum: ["open", "allowlist", "disabled"],
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    config: {
+        listAccountIds: (cfg) => listMeetAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveMeetAccount({ cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultMeetAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => {
+            const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+            if (isDefault) {
+                return {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        meet: {
+                            ...cfg.channels?.meet,
+                            enabled,
+                        },
+                    },
+                };
+            }
+            if (isFlatAccountConfig(cfg, accountId)) {
+                const key = getFlatAccountKey(accountId);
+                return {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        [key]: {
+                            ...cfg.channels?.[key],
+                            enabled,
+                        },
+                    },
+                };
+            }
+            const meetCfg = cfg.channels?.meet;
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    meet: {
+                        ...meetCfg,
+                        accounts: {
+                            ...meetCfg?.accounts,
+                            [accountId]: {
+                                ...meetCfg?.accounts?.[accountId],
+                                enabled,
+                            },
+                        },
+                    },
+                },
+            };
+        },
+        deleteAccount: ({ cfg, accountId }) => {
+            const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+            if (isDefault) {
+                const next = { ...cfg };
+                const nextChannels = { ...cfg.channels };
+                delete nextChannels.meet;
+                if (Object.keys(nextChannels).length > 0) {
+                    next.channels = nextChannels;
+                }
+                else {
+                    delete next.channels;
+                }
+                return next;
+            }
+            if (isFlatAccountConfig(cfg, accountId)) {
+                const key = getFlatAccountKey(accountId);
+                const next = { ...cfg };
+                const nextChannels = { ...cfg.channels };
+                delete nextChannels[key];
+                if (Object.keys(nextChannels).length > 0) {
+                    next.channels = nextChannels;
+                }
+                else {
+                    delete next.channels;
+                }
+                return next;
+            }
+            const meetCfg = cfg.channels?.meet;
+            const accounts = { ...meetCfg?.accounts };
+            delete accounts[accountId];
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    meet: {
+                        ...meetCfg,
+                        accounts: Object.keys(accounts).length > 0 ? accounts : undefined,
+                    },
+                },
+            };
+        },
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            name: account.name,
+            apiEndpoint: account.apiEndpoint,
+        }),
+        resolveAllowFrom: ({ cfg, accountId }) => {
+            const account = resolveMeetAccount({ cfg, accountId });
+            return (account.config?.allowFrom ?? [])
+                .map((entry) => String(entry).trim())
+                .filter(Boolean);
+        },
+        formatAllowFrom: ({ allowFrom }) => allowFrom
+            .map((entry) => String(entry).trim())
+            .filter(Boolean)
+            .map((entry) => entry.toLowerCase()),
+    },
+    security: {
+        collectWarnings: ({ cfg, accountId }) => {
+            const account = resolveMeetAccount({ cfg, accountId });
+            const meetCfg = account.config;
+            const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+            const groupPolicy = meetCfg?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+            if (groupPolicy !== "open")
+                return [];
+            return [
+                `- Meet[${account.accountId}] groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.meet.groupPolicy="allowlist" + channels.meet.groupAllowFrom to restrict senders.`,
+            ];
+        },
+    },
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountConfig: ({ cfg, accountId }) => {
+            const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+            if (isDefault) {
+                return {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        meet: {
+                            ...cfg.channels?.meet,
+                            enabled: true,
+                        },
+                    },
+                };
+            }
+            if (isFlatAccountConfig(cfg, accountId)) {
+                const key = getFlatAccountKey(accountId);
+                return {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        [key]: {
+                            ...cfg.channels?.[key],
+                            enabled: true,
+                        },
+                    },
+                };
+            }
+            const meetCfg = cfg.channels?.meet;
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    meet: {
+                        ...meetCfg,
+                        accounts: {
+                            ...meetCfg?.accounts,
+                            [accountId]: {
+                                ...meetCfg?.accounts?.[accountId],
+                                enabled: true,
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    messaging: {
+        normalizeTarget: (raw) => {
+            const target = parseMeetTarget(raw);
+            return target ? formatMeetTarget(target) : raw;
+        },
+        targetResolver: {
+            looksLikeId: looksLikeMeetId,
+            hint: "<userId|user:<id>|channel:<id>>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async () => [],
+        listGroups: async () => [],
+        listPeersLive: async () => [],
+        listGroupsLive: async () => [],
+    },
+    outbound: meetOutbound,
+    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: snapshot.port ?? null,
+            probe: snapshot.probe,
+            lastProbeAt: snapshot.lastProbeAt ?? null,
+        }),
+        probeAccount: async ({ account }) => ({
+            ok: account.configured,
+            error: account.configured ? undefined : "Not configured",
+            botId: account.apiToken?.split(":")[0],
+        }),
+        buildAccountSnapshot: ({ account, runtime, probe }) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            name: account.name,
+            apiEndpoint: account.apiEndpoint,
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            port: runtime?.port ?? null,
+            probe,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { monitorMeetProvider } = await import("./monitor.js");
+            resolveMeetAccount({
+                cfg: ctx.cfg,
+                accountId: ctx.accountId,
+            });
+            ctx.log?.info(`[${ctx.accountId}] starting`);
+            return monitorMeetProvider({
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+                accountId: ctx.accountId,
+            });
+        },
+    },
+};

package/dist/src/client.d.ts

@@ -0,0 +1,8 @@
+import { MeetBot } from "@meet-im/meet-bot-jssdk";
+import type { PollingOptions } from "@meet-im/meet-bot-jssdk";
+import type { ResolvedMeetAccount } from "./types.js";
+export declare function createMeetClient(account: ResolvedMeetAccount): MeetBot;
+export declare function getPollingOptions(account: ResolvedMeetAccount): PollingOptions;
+export declare function getMeetClient(accountId: string): MeetBot | undefined;
+export declare function closeMeetClient(accountId: string): void;
+export declare function closeAllMeetClients(): void;

package/dist/src/client.js

@@ -0,0 +1,49 @@
+import { MeetBot, POLLING } from "@meet-im/meet-bot-jssdk";
+const botInstances = new Map();
+export function createMeetClient(account) {
+    const existing = botInstances.get(account.accountId);
+    if (existing) {
+        return existing;
+    }
+    if (!account.apiToken) {
+        throw new Error(`Meet account "${account.accountId}" missing apiToken`);
+    }
+    const pollTimeoutMs = account.config.pollTimeout ?? 30000;
+    const pollTimeoutSec = Math.floor(pollTimeoutMs / 1000);
+    const logLevel = account.config.logLevel ?? "silent";
+    const bot = new MeetBot({
+        token: account.apiToken,
+        baseUrl: account.apiEndpoint,
+        pollingLimit: account.config.pollLimit ?? POLLING.DEFAULT_LIMIT,
+        longPollingTimeout: pollTimeoutSec,
+        logLevel,
+        useV2: true,
+    });
+    botInstances.set(account.accountId, bot);
+    return bot;
+}
+export function getPollingOptions(account) {
+    const pollTimeoutMs = account.config.pollTimeout ?? 30000;
+    const pollTimeoutSec = Math.floor(pollTimeoutMs / 1000);
+    return {
+        timeout: pollTimeoutSec,
+        limit: account.config.pollLimit ?? POLLING.DEFAULT_LIMIT,
+        retryDelay: POLLING.DEFAULT_RETRY_DELAY,
+        maxRetries: 0,
+    };
+}
+export function getMeetClient(accountId) {
+    return botInstances.get(accountId);
+}
+export function closeMeetClient(accountId) {
+    const bot = botInstances.get(accountId);
+    if (bot) {
+        bot.stopPolling();
+        botInstances.delete(accountId);
+    }
+}
+export function closeAllMeetClients() {
+    for (const [accountId] of botInstances) {
+        closeMeetClient(accountId);
+    }
+}

package/dist/src/config-schema.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const MeetChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const MeetGroupConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodOptional<z.ZodString>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    users: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export declare const MeetAccountConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodOptional<z.ZodString>;
+    apiEndpoint: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    apiToken: z.ZodOptional<z.ZodString>;
+    pollTimeout: z.ZodOptional<z.ZodNumber>;
+    pollLimit: z.ZodOptional<z.ZodNumber>;
+    logLevel: z.ZodOptional<z.ZodEnum<{
+        silent: "silent";
+        info: "info";
+    }>>;
+}, z.core.$strip>;
+export declare const MeetConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    defaultAccount: z.ZodOptional<z.ZodString>;
+    apiEndpoint: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    apiToken: z.ZodOptional<z.ZodString>;
+    pollTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pollLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    logLevel: z.ZodOptional<z.ZodEnum<{
+        silent: "silent";
+        info: "info";
+    }>>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        pairing: "pairing";
+        allowlist: "allowlist";
+    }>>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        allowlist: "allowlist";
+        disabled: "disabled";
+    }>>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+        requireMention: z.ZodOptional<z.ZodBoolean>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        users: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strip>>>;
+    requireMention: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        requireMention: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    historyLimit: z.ZodOptional<z.ZodNumber>;
+    dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    mediaMaxMb: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+        apiEndpoint: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        apiToken: z.ZodOptional<z.ZodString>;
+        pollTimeout: z.ZodOptional<z.ZodNumber>;
+        pollLimit: z.ZodOptional<z.ZodNumber>;
+        logLevel: z.ZodOptional<z.ZodEnum<{
+            silent: "silent";
+            info: "info";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;

package/dist/src/config-schema.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export const MeetChannelConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    systemPrompt: z.string().optional(),
+    requireMention: z.boolean().optional(),
+});
+export const MeetGroupConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    name: z.string().optional(),
+    requireMention: z.boolean().optional(),
+    systemPrompt: z.string().optional(),
+    users: z.array(z.union([z.string(), z.number()])).optional(),
+});
+export const MeetAccountConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    name: z.string().optional(),
+    apiEndpoint: z.string().optional(),
+    token: z.string().optional(),
+    apiToken: z.string().optional(),
+    pollTimeout: z.number().min(1000).max(300000).optional(),
+    pollLimit: z.number().min(1).max(1000).optional(),
+    logLevel: z.enum(["silent", "info"]).optional(),
+});
+export const MeetConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    defaultAccount: z.string().optional(),
+    apiEndpoint: z.string().optional(),
+    token: z.string().optional(),
+    apiToken: z.string().optional(),
+    pollTimeout: z.number().min(1000).max(300000).optional().default(30000),
+    pollLimit: z.number().min(1).max(1000).optional().default(100),
+    logLevel: z.enum(["silent", "info"]).optional(),
+    dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional().default("pairing"),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional().default("allowlist"),
+    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groups: z.record(z.string(), MeetGroupConfigSchema).optional(),
+    requireMention: z.boolean().optional().default(true),
+    systemPrompt: z.string().optional(),
+    channels: z.record(z.string(), MeetChannelConfigSchema).optional(),
+    historyLimit: z.number().min(0).optional(),
+    dmHistoryLimit: z.number().min(0).optional(),
+    textChunkLimit: z.number().min(1).optional(),
+    mediaMaxMb: z.number().min(0).optional().default(30),
+    accounts: z.record(z.string(), MeetAccountConfigSchema).optional(),
+});

package/dist/src/media.d.ts

@@ -0,0 +1,57 @@
+import type { MeetMediaAttachment } from "./types.js";
+export declare function setMediaDebugLogger(log: (msg: string) => void, error: (msg: string) => void): void;
+/**
+ * 获取文件下载 URL
+ */
+export declare function getFileAccessUrl(params: {
+    accountId: string;
+    sessionInfo: {
+        firstId: number;
+        secondId: number;
+        sessionType: number;
+        companyId?: number;
+    };
+    seqId: number;
+    fileId: string | number;
+    ossProcess?: string;
+}): Promise<string | null>;
+/**
+ * 媒体信息（下载并保存后的结果）
+ */
+export type ResolvedMedia = {
+    path: string;
+    contentType?: string;
+    placeholder: string;
+    url?: string;
+};
+/**
+ * 下载媒体文件到本地 media store
+ * 与 Discord 保持一致的处理流程
+ */
+export declare function downloadAndSaveMedia(params: {
+    accountId: string;
+    attachment: MeetMediaAttachment;
+    sessionInfo: {
+        firstId: number;
+        secondId: number;
+        sessionType: number;
+        companyId?: number;
+    };
+    seqId: number;
+    maxBytes?: number;
+}): Promise<ResolvedMedia | null>;
+/**
+ * 批量处理媒体附件
+ */
+export declare function resolveMediaAttachments(params: {
+    accountId: string;
+    attachments: MeetMediaAttachment[];
+    sessionInfo: {
+        firstId: number;
+        secondId: number;
+        sessionType: number;
+        companyId?: number;
+    };
+    seqId: number;
+    maxBytes?: number;
+}): Promise<ResolvedMedia[]>;