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

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

@@ -0,0 +1,89 @@
+/**
+ * 消息 API：封装文本、媒体、typing、已读与心跳等平台请求。
+ * 调用方传入明确地址和凭据，幂等编号支持安全重试；此层不发起 AgentRun。
+ */
+import type { ChannelType } from "./types.js";
+import { MessageType, type MentionEntity, type RichTextBlock, type SendMessageResult } from "./types.js";
+/**
+ * Send a media message (image or file) to a channel.
+ */
+export declare function sendMediaMessage(params: {
+    apiUrl: string;
+    botToken: string;
+    channelId: string;
+    channelType: ChannelType;
+    type: MessageType;
+    url: string;
+    name?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    mentionUids?: string[];
+    mentionEntities?: MentionEntity[];
+    onBehalfOf?: string;
+    clientMsgNo?: string;
+    signal?: AbortSignal;
+}): Promise<SendMessageResult | undefined>;
+export declare function sendMessage(params: {
+    apiUrl: string;
+    botToken: string;
+    channelId: string;
+    channelType: ChannelType;
+    content: string;
+    mentionUids?: string[];
+    mentionEntities?: MentionEntity[];
+    mentionAll?: boolean;
+    replyMsgId?: string;
+    onBehalfOf?: string;
+    clientMsgNo?: string;
+    signal?: AbortSignal;
+}): Promise<SendMessageResult | undefined>;
+/**
+ * 发送一条 RichText(=14) 图文混排消息。
+ *
+ * 替代「sendMessage 文本 + 循环 uploadMedia」的多次 HTTP：调用方先批量上传图片
+ * 拿到 url（含 width/height），再把文本与图片按顺序组成一条 `content` block 数组
+ * 提交。一条 payload = 一次 HTTP，server 端图文不再拆条。
+ *
+ * 契约（见 octo-lib richtext.go）：
+ *   - `content` 必填且非空；text block 的 text 非空、image block 的 url 为
+ *     http/https 且 width/height >0 —— 校验由调用方/ server 负责，本函数只组装。
+ *   - `plain` 出站可附带（供老客户端/降级），server 会用 content 权威重算覆盖。
+ *   - `client_msg_no` 默认自动生成（幂等去重），调用方可显式传入复用。
+ */
+export declare function sendRichTextMessage(params: {
+    apiUrl: string;
+    botToken: string;
+    channelId: string;
+    channelType: ChannelType;
+    blocks: RichTextBlock[];
+    plain?: string;
+    mentionUids?: string[];
+    mentionEntities?: MentionEntity[];
+    mentionAll?: boolean;
+    replyMsgId?: string;
+    onBehalfOf?: string;
+    clientMsgNo?: string;
+    signal?: AbortSignal;
+}): Promise<SendMessageResult | undefined>;
+export declare function sendTyping(params: {
+    apiUrl: string;
+    botToken: string;
+    channelId: string;
+    channelType: ChannelType;
+    onBehalfOf?: string;
+    signal?: AbortSignal;
+}): Promise<void>;
+export declare function sendReadReceipt(params: {
+    apiUrl: string;
+    botToken: string;
+    channelId: string;
+    channelType: ChannelType;
+    messageIds?: string[];
+    signal?: AbortSignal;
+}): Promise<void>;
+export declare function sendHeartbeat(params: {
+    apiUrl: string;
+    botToken: string;
+    signal?: AbortSignal;
+}): Promise<void>;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/api/messages.js

@@ -0,0 +1,173 @@
+import { MessageType } from "./types.js";
+import { postJson, generateClientMsgNo } from "./client.js";
+/**
+ * Send a media message (image or file) to a channel.
+ */
+export async function sendMediaMessage(params) {
+    // Last-line guard: never POST an empty channel_id — the server answers an
+    // opaque 500. Upstream resolvers should already reject this, but any future
+    // caller that bypasses them is stopped here. (#138)
+    if (!params.channelId || !params.channelId.trim()) {
+        throw new Error("octo: channelId is required to send a message");
+    }
+    const payload = {
+        type: params.type,
+        url: params.url
+    };
+    // Image (type=2) needs width/height/name/size; File (type=8) needs name/size
+    if (params.type === MessageType.Image) {
+        if (params.width)
+            payload.width = params.width;
+        if (params.height)
+            payload.height = params.height;
+        if (params.name)
+            payload.name = params.name;
+        if (params.size != null)
+            payload.size = params.size;
+    }
+    else {
+        if (params.name)
+            payload.name = params.name;
+        if (params.size != null)
+            payload.size = params.size;
+    }
+    if ((params.mentionUids && params.mentionUids.length > 0) ||
+        (params.mentionEntities && params.mentionEntities.length > 0)) {
+        const mention = {};
+        if (params.mentionUids && params.mentionUids.length > 0) {
+            mention.uids = params.mentionUids;
+        }
+        if (params.mentionEntities && params.mentionEntities.length > 0) {
+            mention.entities = params.mentionEntities;
+        }
+        payload.mention = mention;
+    }
+    return await postJson(params.apiUrl, params.botToken, "/v1/bot/sendMessage", {
+        channel_id: params.channelId,
+        channel_type: params.channelType,
+        payload,
+        client_msg_no: params.clientMsgNo ?? generateClientMsgNo(),
+        ...(params.onBehalfOf ? { on_behalf_of: params.onBehalfOf } : {})
+    }, params.signal);
+}
+// SendMessageResult: use the canonical definition from types.ts
+// (message_id is string due to int64 protection in postJson)
+export async function sendMessage(params) {
+    // Last-line guard: never POST an empty channel_id — the server answers an
+    // opaque 500. Upstream resolvers should already reject this, but any future
+    // caller that bypasses them is stopped here. (#138)
+    if (!params.channelId || !params.channelId.trim()) {
+        throw new Error("octo: channelId is required to send a message");
+    }
+    const payload = {
+        type: MessageType.Text,
+        content: params.content
+    };
+    // Add mention field if any UIDs specified, entities present, or mentionAll
+    if ((params.mentionUids && params.mentionUids.length > 0) ||
+        (params.mentionEntities && params.mentionEntities.length > 0) ||
+        params.mentionAll) {
+        const mention = {};
+        if (params.mentionUids && params.mentionUids.length > 0) {
+            mention.uids = params.mentionUids;
+        }
+        if (params.mentionEntities && params.mentionEntities.length > 0) {
+            mention.entities = params.mentionEntities;
+        }
+        if (params.mentionAll) {
+            mention.all = 1;
+        }
+        payload.mention = mention;
+    }
+    // Add reply field if replyMsgId is provided
+    if (params.replyMsgId) {
+        payload.reply = { message_id: params.replyMsgId };
+    }
+    return await postJson(params.apiUrl, params.botToken, "/v1/bot/sendMessage", {
+        channel_id: params.channelId,
+        channel_type: params.channelType,
+        payload,
+        client_msg_no: params.clientMsgNo ?? generateClientMsgNo(),
+        ...(params.onBehalfOf ? { on_behalf_of: params.onBehalfOf } : {})
+    }, params.signal);
+}
+/**
+ * 发送一条 RichText(=14) 图文混排消息。
+ *
+ * 替代「sendMessage 文本 + 循环 uploadMedia」的多次 HTTP：调用方先批量上传图片
+ * 拿到 url（含 width/height），再把文本与图片按顺序组成一条 `content` block 数组
+ * 提交。一条 payload = 一次 HTTP，server 端图文不再拆条。
+ *
+ * 契约（见 octo-lib richtext.go）：
+ *   - `content` 必填且非空；text block 的 text 非空、image block 的 url 为
+ *     http/https 且 width/height >0 —— 校验由调用方/ server 负责，本函数只组装。
+ *   - `plain` 出站可附带（供老客户端/降级），server 会用 content 权威重算覆盖。
+ *   - `client_msg_no` 默认自动生成（幂等去重），调用方可显式传入复用。
+ */
+export async function sendRichTextMessage(params) {
+    // Last-line guard: never POST an empty channel_id — the server answers an
+    // opaque 500. Upstream resolvers should already reject this, but any future
+    // caller that bypasses them is stopped here. (#138)
+    if (!params.channelId || !params.channelId.trim()) {
+        throw new Error("octo: channelId is required to send a message");
+    }
+    const payload = {
+        type: MessageType.RichText,
+        content: params.blocks
+    };
+    if (typeof params.plain === "string") {
+        payload.plain = params.plain;
+    }
+    if ((params.mentionUids && params.mentionUids.length > 0) ||
+        (params.mentionEntities && params.mentionEntities.length > 0) ||
+        params.mentionAll) {
+        const mention = {};
+        if (params.mentionUids && params.mentionUids.length > 0) {
+            mention.uids = params.mentionUids;
+        }
+        if (params.mentionEntities && params.mentionEntities.length > 0) {
+            mention.entities = params.mentionEntities;
+        }
+        if (params.mentionAll) {
+            mention.all = 1;
+        }
+        payload.mention = mention;
+    }
+    if (params.replyMsgId) {
+        payload.reply = { message_id: params.replyMsgId };
+    }
+    return await postJson(params.apiUrl, params.botToken, "/v1/bot/sendMessage", {
+        channel_id: params.channelId,
+        channel_type: params.channelType,
+        payload,
+        client_msg_no: params.clientMsgNo ?? generateClientMsgNo(),
+        ...(params.onBehalfOf ? { on_behalf_of: params.onBehalfOf } : {})
+    }, params.signal);
+}
+export async function sendTyping(params) {
+    await postJson(params.apiUrl, params.botToken, "/v1/bot/typing", {
+        channel_id: params.channelId,
+        channel_type: params.channelType,
+        ...(params.onBehalfOf ? { on_behalf_of: params.onBehalfOf } : {})
+        // A discardable hint, re-sent every few seconds while the model works. Retrying it
+        // only adds pressure to a bucket that is already empty.
+    }, params.signal, { retryOn429: false });
+}
+export async function sendReadReceipt(params) {
+    await postJson(params.apiUrl, params.botToken, "/v1/bot/readReceipt", {
+        channel_id: params.channelId,
+        channel_type: params.channelType,
+        ...(params.messageIds && params.messageIds.length > 0
+            ? { message_ids: params.messageIds }
+            : {})
+        // Same reasoning as typing: nothing downstream depends on this landing.
+    }, params.signal, { retryOn429: false });
+}
+export async function sendHeartbeat(params) {
+    await postJson(params.apiUrl, params.botToken, "/v1/bot/heartbeat", {}, params.signal, {
+        // A missed beat costs nothing: the next one is one interval away, and no server-side
+        // reader consumes the heartbeat key. Sleeping inside the call would only add pressure
+        // to a bucket that is already empty, and would hold the beat's single-flight slot.
+        retryOn429: false
+    });
+}

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

@@ -0,0 +1,84 @@
+export interface RuleDocument {
+    content: string;
+    version: number;
+    updated_at: string | null;
+    updated_by: string;
+}
+/**
+ * 群级免@偏好（per-group mention preference）。
+ *
+ * 后端 octo-server#237 暴露 GET /v1/bot/groups/:group_no/mention_pref。
+ * 两个权限轴 AND 合成（octo-server YUJ-2996）：
+ *  - `no_mention`：bot 主人意愿（bot_mention_pref，无记录=false）
+ *  - `group_allow_no_mention`：群主/管理员的群级总开关（group.allow_no_mention，
+ *    无群记录回退默认 true=允许）
+ *  - `effective = no_mention && group_allow_no_mention`：最终是否免@即可触发。
+ *
+ * gate 只看 `effective`。`no_mention` / `group_allow_no_mention` 保留供观测/日志，
+ * 并为旧 server（仅返回 no_mention）提供回退。
+ */
+export interface MentionPref {
+    /** bot 主人意愿轴。旧 server 只有这个字段。 */
+    no_mention: boolean;
+    /** 群级总开关轴；无群记录回退 true（允许）。 */
+    group_allow_no_mention: boolean;
+    /** 两轴 AND：免@即可触发回复。gate 据此决策。 */
+    effective: boolean;
+}
+/**
+ * 获取某群对当前 bot 的免@偏好。
+ *
+ * 失败（网络错误 / 非 2xx / 解析失败）一律回退到账号级行为
+ * （effective=false，即保持需@），绝不抛错，避免 gate 崩溃。
+ *
+ * 兼容旧 server：YUJ-2996 之前的 server 只返回 `{ no_mention }`，没有
+ * `effective` / `group_allow_no_mention`。此时 group 轴缺省视为 true（允许），
+ * effective 回退为 no_mention，行为与升级前完全一致（零回归）。
+ */
+export declare function getMentionPref(params: {
+    apiUrl: string;
+    botToken: string;
+    groupNo: string;
+    log?: {
+        info?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}): Promise<MentionPref>;
+export declare function getGroupMd(params: {
+    apiUrl: string;
+    botToken: string;
+    groupNo: string;
+    signal?: AbortSignal;
+    log?: {
+        info?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}): Promise<{
+    content: string;
+    version: number;
+    updated_at: string | null;
+    updated_by: string;
+}>;
+/**
+ * Get thread THREAD.md content (throws on non-2xx — used by agent-tools).
+ * GET /v1/bot/groups/{groupNo}/threads/{shortId}/md
+ *
+ * See also: group-md.ts `fetchThreadMdFromApi()` which returns null on error
+ * and is used for background cache refresh where failures are non-fatal.
+ */
+export declare function getThreadMd(params: {
+    apiUrl: string;
+    botToken: string;
+    groupNo: string;
+    shortId: string;
+    signal?: AbortSignal;
+    log?: {
+        info?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}): Promise<{
+    content: string;
+    version: number;
+    updated_at: string | null;
+    updated_by: string;
+}>;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/api/rules.js

@@ -0,0 +1,109 @@
+/**
+ * 规则 API：读取 GROUP.md、话题规则及群级 @ 偏好，保留服务端版本与权限结果。
+ * 规则正文是 Context 材料，不在此转为执行指令；触发偏好与正文材料各自处理。
+ */
+// Adapted from Mininglamp-OSS/openclaw-channel-octo/src/api-fetch.ts.
+import { DEFAULT_TIMEOUT_MS } from "./client.js";
+import { OctoApiError } from "./errors.js";
+// Short timeout for the per-message mention_pref hot-path lookup. On a cache
+// miss this fires on the first message of every group every TTL window; before
+// the backend ships it 404s, and we must not stall the inbound pipeline for the
+// full 30s. A failed/slow lookup just falls back to the account-level config.
+const MENTION_PREF_TIMEOUT_MS = 3_000;
+/**
+ * 获取某群对当前 bot 的免@偏好。
+ *
+ * 失败（网络错误 / 非 2xx / 解析失败）一律回退到账号级行为
+ * （effective=false，即保持需@），绝不抛错，避免 gate 崩溃。
+ *
+ * 兼容旧 server：YUJ-2996 之前的 server 只返回 `{ no_mention }`，没有
+ * `effective` / `group_allow_no_mention`。此时 group 轴缺省视为 true（允许），
+ * effective 回退为 no_mention，行为与升级前完全一致（零回归）。
+ */
+export async function getMentionPref(params) {
+    const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/groups/${encodeURIComponent(params.groupNo)}/mention_pref`;
+    try {
+        const resp = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${params.botToken}`
+            },
+            signal: AbortSignal.timeout(MENTION_PREF_TIMEOUT_MS)
+        });
+        if (!resp.ok) {
+            // 404 = the mention_pref endpoint isn't deployed yet (expected during
+            // rollout before octo-server#237 ships); 401 = empty/short-lived Bearer.
+            // Both are benign — we fall back to effective=false below — and recur on
+            // every inbound message, so logging them at error level (compounded by
+            // the 30s negative-cache TTL) makes a healthy rollout look broken. Log
+            // expected statuses at info and reserve error for genuinely unexpected
+            // responses (5xx, etc.).
+            const expected = resp.status === 404 || resp.status === 401;
+            const msg = `octo: getMentionPref(${params.groupNo}) failed: ${resp.status}`;
+            if (expected)
+                params.log?.info?.(msg);
+            else
+                params.log?.error?.(msg);
+            return { no_mention: false, group_allow_no_mention: true, effective: false };
+        }
+        const data = (await resp.json());
+        // Accept boolean `true` or numeric `1` (DB/JSON may serialize either),
+        // mirroring the mention.{all,ais,humans} coercion in inbound.ts.
+        const noMention = data?.no_mention === true || data?.no_mention === 1;
+        // Old server omits group_allow_no_mention → default true (allow), so the
+        // group axis is a no-op and effective degrades to noMention (zero regression).
+        const groupAllow = data?.group_allow_no_mention === undefined
+            ? true
+            : data.group_allow_no_mention === true || data.group_allow_no_mention === 1;
+        // Old server omits effective → fall back to the AND of the two axes (which,
+        // with groupAllow defaulting true, equals noMention).
+        const effective = data?.effective === undefined
+            ? noMention && groupAllow
+            : data.effective === true || data.effective === 1;
+        return { no_mention: noMention, group_allow_no_mention: groupAllow, effective };
+    }
+    catch (err) {
+        params.log?.error?.(`octo: getMentionPref(${params.groupNo}) error: ${err instanceof Error ? err.name : "unknown"}`);
+        return { no_mention: false, group_allow_no_mention: true, effective: false };
+    }
+}
+// Fetch GROUP.md content for a group
+export async function getGroupMd(params) {
+    const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/groups/${encodeURIComponent(params.groupNo)}/md`;
+    const resp = await fetch(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${params.botToken}`
+        },
+        signal: params.signal
+            ? AbortSignal.any([params.signal, AbortSignal.timeout(DEFAULT_TIMEOUT_MS)])
+            : AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        throw OctoApiError.from(resp, "getGroupMd", text);
+    }
+    return (await resp.json());
+}
+/**
+ * Get thread THREAD.md content (throws on non-2xx — used by agent-tools).
+ * GET /v1/bot/groups/{groupNo}/threads/{shortId}/md
+ *
+ * See also: group-md.ts `fetchThreadMdFromApi()` which returns null on error
+ * and is used for background cache refresh where failures are non-fatal.
+ */
+export async function getThreadMd(params) {
+    const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/groups/${encodeURIComponent(params.groupNo)}/threads/${encodeURIComponent(params.shortId)}/md`;
+    const resp = await fetch(url, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${params.botToken}` },
+        signal: params.signal
+            ? AbortSignal.any([params.signal, AbortSignal.timeout(DEFAULT_TIMEOUT_MS)])
+            : AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        throw OctoApiError.from(resp, "getThreadMd", text);
+    }
+    return (await resp.json());
+}

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

@@ -0,0 +1,87 @@
+/**
+ * Octo 线协议类型：保留平台消息、卡片、事件与媒体字段的原始含义。
+ * 与 Provider/AgentRun 协议分离，跨层转换由 connector 完成，避免身份和状态混用。
+ */
+/**
+ * 单个 mention 的精确位置描述。
+ * offset/length 的单位为 UTF-16 code units（与 JS string.length 一致）。
+ */
+export interface MentionEntity {
+    /** 被 @ 用户的唯一标识符 */
+    uid: string;
+    /** @name 在 content 中的起始位置（包括 @ 符号） */
+    offset: number;
+    /** @name 的完整长度（包括 @ 符号） */
+    length: number;
+}
+export interface SendMessageResult {
+    message_id: string;
+    client_msg_no: string;
+    message_seq: number;
+}
+/** Channel types */
+export declare enum ChannelType {
+    DM = 1,
+    Group = 2,
+    CommunityTopic = 5
+}
+/** Message content types */
+export declare enum MessageType {
+    Text = 1,
+    Image = 2,
+    GIF = 3,
+    Voice = 4,
+    Video = 5,
+    Location = 6,
+    Card = 7,
+    File = 8,
+    MultipleForward = 11,
+    /**
+     * 图文混排（rich text）。复用 octo-lib Phase 0 已定的 ContentType=14（见
+     * octo-lib common/richtext.go）。正文以有序 `content` block 数组承载，数组
+     * 顺序即图文穿插顺序；顶层 `plain` 为冗余纯文本，契约上由 server 权威生成。
+     */
+    RichText = 14,
+    /**
+     * 交互卡片（Adaptive Cards 1.5 子集，"octo/v1" profile）。对应 octo-server
+     * PR #525 P1 `card-message-protocol`，ContentType=17。
+     *
+     * ⚠️ 与 `Card=7`（名片/contact card）语义无关 —— octo-server Decision 1 明确
+     * InteractiveCard(17) ≠ common.Card(7)，不要把新逻辑接到 7 上。
+     *
+     * payload 信封：`{ type:17, card:{标准 AC1.5 JSON}, plain:"(server 权威重算)" }`
+     * + 顶层 `profile`/`card_version`。adapter 入站仅消费服务端权威 `plain`。
+     */
+    InteractiveCard = 17
+}
+/** RichText(=14) 单个 block 类型常量（与 octo-lib RichTextBlockText/Image 对齐）。 */
+export declare const RICH_TEXT_BLOCK_TEXT = "text";
+export declare const RICH_TEXT_BLOCK_IMAGE = "image";
+/**
+ * RichText(=14) `content` 数组中的单个 block。
+ *   - type=text  使用 `text`（纯文本，MVP 不渲染 markdown）；
+ *   - type=image 使用 `url`/`width`/`height`（`size`、`name` 可选）。
+ *
+ * ⚠️ 命名锁定（见 octo-lib richtext.go）：禁止使用 entities + offset/length。
+ */
+export interface RichTextBlock {
+    type: string;
+    /** text block 文本内容（type=text 必填且非空）。 */
+    text?: string;
+    /** image block 图片地址（type=image 必填，scheme 仅 http/https）。 */
+    url?: string;
+    /** image block 宽度（像素，契约必填且 >0，供端上占位排版避免抖动）。 */
+    width?: number;
+    /** image block 高度（像素，契约必填且 >0）。 */
+    height?: number;
+    /** image block 字节大小（可选）。 */
+    size?: number;
+    /** image block 原始文件名（可选）。 */
+    name?: string;
+}
+export interface BotEvent {
+    event_id: number;
+    event_type?: string;
+    event_data?: Record<string, unknown>;
+    message?: Record<string, unknown>;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/api/types.js

@@ -0,0 +1,45 @@
+/**
+ * Octo 线协议类型：保留平台消息、卡片、事件与媒体字段的原始含义。
+ * 与 Provider/AgentRun 协议分离，跨层转换由 connector 完成，避免身份和状态混用。
+ */
+// Octo wire types copied from openclaw-channel-octo; independent of Provider events.
+/** Channel types */
+export var ChannelType;
+(function (ChannelType) {
+    ChannelType[ChannelType["DM"] = 1] = "DM";
+    ChannelType[ChannelType["Group"] = 2] = "Group";
+    ChannelType[ChannelType["CommunityTopic"] = 5] = "CommunityTopic"; // Thread/子区
+})(ChannelType || (ChannelType = {}));
+/** Message content types */
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Text"] = 1] = "Text";
+    MessageType[MessageType["Image"] = 2] = "Image";
+    MessageType[MessageType["GIF"] = 3] = "GIF";
+    MessageType[MessageType["Voice"] = 4] = "Voice";
+    MessageType[MessageType["Video"] = 5] = "Video";
+    MessageType[MessageType["Location"] = 6] = "Location";
+    MessageType[MessageType["Card"] = 7] = "Card";
+    MessageType[MessageType["File"] = 8] = "File";
+    MessageType[MessageType["MultipleForward"] = 11] = "MultipleForward";
+    /**
+     * 图文混排（rich text）。复用 octo-lib Phase 0 已定的 ContentType=14（见
+     * octo-lib common/richtext.go）。正文以有序 `content` block 数组承载，数组
+     * 顺序即图文穿插顺序；顶层 `plain` 为冗余纯文本，契约上由 server 权威生成。
+     */
+    MessageType[MessageType["RichText"] = 14] = "RichText";
+    /**
+     * 交互卡片（Adaptive Cards 1.5 子集，"octo/v1" profile）。对应 octo-server
+     * PR #525 P1 `card-message-protocol`，ContentType=17。
+     *
+     * ⚠️ 与 `Card=7`（名片/contact card）语义无关 —— octo-server Decision 1 明确
+     * InteractiveCard(17) ≠ common.Card(7)，不要把新逻辑接到 7 上。
+     *
+     * payload 信封：`{ type:17, card:{标准 AC1.5 JSON}, plain:"(server 权威重算)" }`
+     * + 顶层 `profile`/`card_version`。adapter 入站仅消费服务端权威 `plain`。
+     */
+    MessageType[MessageType["InteractiveCard"] = 17] = "InteractiveCard";
+})(MessageType || (MessageType = {}));
+/** RichText(=14) 单个 block 类型常量（与 octo-lib RichTextBlockText/Image 对齐）。 */
+export const RICH_TEXT_BLOCK_TEXT = "text";
+export const RICH_TEXT_BLOCK_IMAGE = "image";

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

@@ -0,0 +1,5 @@
+/** Resolve tenant scope through the octo-auth verify-bot contract. */
+export declare function verifyBotIdentity(apiUrl: string, token: string, signal: AbortSignal): Promise<{
+    bot_uid: string;
+    space_id: string;
+}>;

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

@@ -0,0 +1,22 @@
+import { connectionFetch, connectionJson, httpConnectionFailure } from "./connection-error.js";
+/** Resolve tenant scope through the octo-auth verify-bot contract. */
+export async function verifyBotIdentity(apiUrl, token, signal) {
+    const response = await connectionFetch(`${apiUrl.replace(/\/+$/, "")}/v1/auth/verify-bot`, {
+        method: "POST",
+        redirect: "error",
+        signal: AbortSignal.any([signal, AbortSignal.timeout(15_000)]),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ bot_token: token })
+    }, "AUTH");
+    if (!response.ok) {
+        throw await httpConnectionFailure(response, "AUTH");
+    }
+    const data = (await connectionJson(response, "AUTH", "IM_AUTH_IDENTITY_INVALID"));
+    if (!data ||
+        typeof data.bot_uid !== "string" ||
+        !data.bot_uid ||
+        typeof data.space_id !== "string" ||
+        !data.space_id)
+        throw new Error("IM_AUTH_IDENTITY_INVALID");
+    return { bot_uid: data.bot_uid, space_id: data.space_id };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * 按钮报文解析：提取服务端确认的操作者与原卡片地址，供上层校验 Run 归属。
+ * 表单 data 只是输入，不能覆盖可信身份；按钮不会被合成为新的普通聊天消息。
+ */
+import { ChannelType, type BotEvent } from "./api/types.js";
+export interface CardAction {
+    eventId: number;
+    messageId: string;
+    channelId: string;
+    channelType: ChannelType;
+    actionId: string;
+    inputs: Record<string, string>;
+    operatorUid: string;
+    data?: Record<string, unknown>;
+    spaceId?: string;
+    clientToken?: string;
+    actedAt?: number;
+}
+/** Parse the server-authoritative card_action envelope without trusting form input values. */
+export declare function parseCardAction(event: BotEvent): CardAction | null;