oh-my-im 0.1.0 → 0.1.2

package/README.md

@@ -6,9 +6,11 @@
 
 ```bash
 npm install
-cp .env.example .env
-# 编辑 .env
-npm run dev
+npm run build
+npm link
+omi
 ```
 
+首次运行会在 `~/.oh-my-im` 创建本地配置；在管理页填写钉钉应用凭证、钉钉规则和机器人单聊授权人员即可。`omi` 的状态、日志和全部运行配置都固定保存在此目录，因此可在任意目录执行 `omi status`、`omi stop` 或 `omi update`。
+
 详见 [docs/development.md](docs/development.md)。

package/dist/codex.js

@@ -40,14 +40,18 @@ function buildArgs(prompt, workDir, sessionId, config) {
     if (config.codexPermissionMode === "bypass") {
         common.push("--dangerously-bypass-approvals-and-sandbox");
     }
+    else if (config.codexPermissionMode === "read-only") {
+        common.push("--sandbox", "read-only");
+    }
     else {
         common.push("--full-auto");
     }
+    const modelOptions = config.codexModel ? ["--model", config.codexModel] : [];
     return sessionId
-        ? ["exec", "resume", ...common, sessionId, "-"]
-        : ["exec", ...common, "--cd", workDir, "-"];
+        ? ["exec", "resume", ...common, ...modelOptions, sessionId, "-"]
+        : ["exec", ...common, ...modelOptions, "--cd", workDir, "-"];
 }
-export function runCodex(prompt, sessionId, config) {
+export function runCodex(prompt, sessionId, config, callbacks = {}) {
     return new Promise((resolve, reject) => {
         const start = Date.now();
         const args = buildArgs(prompt, config.codexWorkDir, sessionId, config);
@@ -83,8 +87,20 @@ export function runCodex(prompt, sessionId, config) {
         child.stdin.write(prompt);
         child.stdin.end();
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
+            const text = chunk.toString();
+            stderr += text;
+            for (const line of text.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+                log.debug(`stderr: ${line.slice(0, 1_000)}`);
+            }
         });
+        const fail = (message) => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            child.kill("SIGTERM");
+            reject(new Error(message));
+        };
         const rl = createInterface({ input: child.stdout });
         rl.on("line", (line) => {
             const event = parseJsonLine(line);
@@ -104,9 +120,7 @@ export function runCodex(prompt, sessionId, config) {
                 const err = payload.error;
                 const message = err?.message ?? (typeof payload.message === "string" ? payload.message : "Codex failed");
                 log.error(message);
-                completed = true;
-                clearTimeout(timeout);
-                reject(new Error(message));
+                fail(message);
                 return;
             }
             if (event.type === "response_item" || type === "item.started" || type === "item.updated" || type === "item.completed") {
@@ -116,11 +130,14 @@ export function runCodex(prompt, sessionId, config) {
                     const name = typeof item.name === "string" ? item.name : "tool";
                     toolStats[name] = (toolStats[name] ?? 0) + 1;
                     log.debug(`tool=${name}`);
+                    callbacks.onToolUse?.(name, { ...toolStats });
                     return;
                 }
                 const text = extractText(item);
-                if (text)
+                if (text) {
                     accumulated += (accumulated ? "\n\n" : "") + text;
+                    callbacks.onText?.(accumulated);
+                }
                 return;
             }
             if (type === "task_complete" || type === "turn.completed") {

package/dist/config.js

@@ -1,39 +1,33 @@
-import "dotenv/config";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-function requireEnv(name) {
-    const value = process.env[name]?.trim();
-    if (!value)
-        throw new Error(`Missing required env: ${name}`);
-    return value;
-}
-function splitCsv(value) {
-    if (!value)
-        return [];
-    return value
-        .split(",")
-        .map((item) => item.trim())
-        .filter(Boolean);
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+function loadLocalBotConfig() {
+    const path = join(process.cwd(), ".oh-my-im", "dws-dashboard.json");
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error("未找到 .oh-my-im/dws-dashboard.json，请先启动 omi 并在管理页配置钉钉应用凭证");
+    }
 }
 function resolveWorkDir() {
-    const configured = process.env.CODEX_WORK_DIR?.trim();
-    const dir = configured ? resolve(configured) : process.cwd();
+    const dir = resolve(process.cwd());
     if (!existsSync(dir))
-        throw new Error(`CODEX_WORK_DIR does not exist: ${dir}`);
+        throw new Error(`Codex work directory does not exist: ${dir}`);
     return dir;
 }
 export function loadConfig() {
-    const permissionMode = process.env.CODEX_PERMISSION_MODE?.trim().toLowerCase();
-    const timeoutRaw = process.env.OPEN_IM_CLI_TIMEOUT_MS?.trim();
-    const timeout = timeoutRaw ? Number.parseInt(timeoutRaw, 10) : 30 * 60 * 1000;
+    const local = loadLocalBotConfig();
+    const clientId = local.clientId?.trim();
+    const clientSecret = local.clientSecret?.trim();
+    if (!clientId || !clientSecret)
+        throw new Error("请先在管理页填写钉钉应用 Client ID 和 Client Secret");
     return {
-        dingtalkClientId: requireEnv("DINGTALK_CLIENT_ID"),
-        dingtalkClientSecret: requireEnv("DINGTALK_CLIENT_SECRET"),
-        codexCliPath: process.env.CODEX_CLI_PATH?.trim() || "codex",
+        dingtalkClientId: clientId,
+        dingtalkClientSecret: clientSecret,
+        codexCliPath: "codex",
         codexWorkDir: resolveWorkDir(),
-        codexProxy: process.env.CODEX_PROXY?.trim() || undefined,
-        codexPermissionMode: permissionMode === "bypass" ? "bypass" : undefined,
-        allowedUserIds: splitCsv(process.env.ALLOWED_USER_IDS),
-        cliTimeoutMs: Number.isFinite(timeout) && timeout > 0 ? timeout : 30 * 60 * 1000,
+        codexPermissionMode: "bypass",
+        allowedUserIds: [...new Set((local.botAllowedUserIds ?? []).map((id) => id.trim()).filter(Boolean))],
+        cliTimeoutMs: 30 * 60 * 1000,
     };
 }

package/dist/dingtalk-card.js

@@ -0,0 +1,116 @@
+import { createLogger } from "./logger.js";
+const log = createLogger("DingTalkCard");
+const apiBase = "https://api.dingtalk.com";
+function buildCardData(title, content) {
+    return JSON.stringify({
+        config: { autoLayout: true, enableForward: true },
+        header: {
+            title: { type: "text", text: title.trim() || "映客活动AI" },
+            logo: "@lALPDfJ6V_FPDmvNAfTNAfQ",
+        },
+        contents: [{ type: "markdown", text: content.trim() || "处理中...", id: "content" }],
+    });
+}
+export class DingTalkCardClient {
+    accessToken;
+    accessTokenExpiresAt = 0;
+    robotCode;
+    clientId;
+    clientSecret;
+    constructor(clientId = "", clientSecret = "", robotCode = "dingn9wrup8mqq1ptabn") {
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.robotCode = robotCode;
+    }
+    setCredentials(clientId, clientSecret) {
+        const nextClientId = clientId.trim();
+        const nextClientSecret = clientSecret.trim();
+        if (this.clientId === nextClientId && this.clientSecret === nextClientSecret)
+            return;
+        this.clientId = nextClientId;
+        this.clientSecret = nextClientSecret;
+        this.accessToken = undefined;
+        this.accessTokenExpiresAt = 0;
+    }
+    setRobotCode(robotCode) {
+        this.robotCode = robotCode.trim();
+    }
+    get enabled() {
+        return Boolean(this.clientId && this.clientSecret && this.robotCode);
+    }
+    async create(groupId, cardBizId, title, content) {
+        if (!this.enabled) {
+            throw new Error("映客活动AI 卡片未启用：DINGTALK_CLIENT_ID 或 DINGTALK_CLIENT_SECRET 缺失");
+        }
+        try {
+            await this.call("POST", "/v1.0/im/v1.0/robot/interactiveCards/send", {
+                cardTemplateId: "StandardCard",
+                cardBizId,
+                outTrackId: cardBizId,
+                robotCode: this.robotCode,
+                openConversationId: groupId,
+                cardData: buildCardData(title, content),
+            });
+            log.info(`card started group=${groupId} card=${cardBizId}`);
+            return { groupId, cardBizId };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log.error(`card start failed: ${message}`);
+            throw new Error(`映客活动AI 卡片发送失败：${message}`);
+        }
+    }
+    async update(handle, title, content) {
+        await this.call("PUT", "/v1.0/im/robots/interactiveCards", {
+            cardBizId: handle.cardBizId,
+            cardData: buildCardData(title, content),
+        });
+        log.debug(`card updated group=${handle.groupId} card=${handle.cardBizId}`);
+    }
+    async call(method, path, body) {
+        const accessToken = await this.getAccessToken();
+        const response = await fetch(`${apiBase}${path}`, {
+            method,
+            headers: {
+                "content-type": "application/json",
+                "x-acs-dingtalk-access-token": accessToken,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(30_000),
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(`DingTalk card API failed: ${response.status} ${text}`);
+        if (!text)
+            return {};
+        const result = JSON.parse(text);
+        const code = result.errcode ?? result.errorCode ?? result.code;
+        if ((typeof code === "number" && code !== 0) ||
+            (typeof code === "string" && code && code !== "0" && code.toLowerCase() !== "ok") ||
+            result.success === false) {
+            throw new Error(`DingTalk card business error: ${text.slice(0, 1_000)}`);
+        }
+        return result;
+    }
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.accessTokenExpiresAt)
+            return this.accessToken;
+        if (!this.clientId || !this.clientSecret)
+            throw new Error("DingTalk app credentials are missing");
+        const response = await fetch(`${apiBase}/v1.0/oauth2/accessToken`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ appKey: this.clientId, appSecret: this.clientSecret }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(`DingTalk token API failed: ${response.status}`);
+        const result = JSON.parse(text);
+        if (!result.accessToken)
+            throw new Error("DingTalk token API returned no accessToken");
+        this.accessToken = result.accessToken;
+        this.accessTokenExpiresAt = Date.now() + Math.max((result.expireIn ?? 7200) - 120, 60) * 1000;
+        return result.accessToken;
+    }
+}

package/dist/dingtalk.js

@@ -1,6 +1,165 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
 import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
 import { createLogger } from "./logger.js";
 const log = createLogger("DingTalk");
+function safePreview(value, limit = 160) {
+    const text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+    return text.length > limit ? `${text.slice(0, limit)}...` : text;
+}
+export function isSingleConversation(type) {
+    const normalized = type?.trim().toLowerCase();
+    return normalized === "0" || normalized === "single" || normalized === "singlechat" || normalized === "oto";
+}
+function buildStandardCardData(title, content) {
+    const safeTitle = title.trim() || "Codex";
+    const safeContent = content.trim() || "...";
+    return JSON.stringify({
+        config: { autoLayout: true, enableForward: true },
+        header: {
+            title: { type: "text", text: safeTitle },
+            logo: "@lALPDfJ6V_FPDmvNAfTNAfQ",
+        },
+        contents: [
+            { type: "markdown", text: safeContent, id: "content" },
+        ],
+    });
+}
+export function parseDingTalkMessage(data) {
+    let payload;
+    try {
+        payload = JSON.parse(data.data);
+    }
+    catch {
+        log.warn(`Failed to parse DingTalk payload: ${safePreview(data.data, 240)}`);
+        return null;
+    }
+    const conversationId = payload.conversationId;
+    const sessionWebhook = payload.sessionWebhook;
+    const senderStaffId = payload.senderStaffId;
+    const senderId = payload.senderId;
+    const conversationType = payload.conversationType;
+    const robotCode = payload.robotCode;
+    const msgtype = payload.msgtype;
+    const textPayload = asRecord(payload.text);
+    const contentPayload = asRecord(payload.content);
+    if (typeof conversationId !== "string" ||
+        typeof sessionWebhook !== "string" ||
+        typeof senderId !== "string" ||
+        typeof msgtype !== "string") {
+        return null;
+    }
+    const text = extractText(msgtype, textPayload, contentPayload);
+    const attachments = extractAttachments(msgtype, contentPayload, payload);
+    return {
+        callbackId: data.headers.messageId,
+        conversationId,
+        conversationType: typeof conversationType === "string" ? conversationType : undefined,
+        sessionWebhook,
+        senderId,
+        senderStaffId: typeof senderStaffId === "string" ? senderStaffId : undefined,
+        senderNick: typeof payload.senderNick === "string" ? payload.senderNick : undefined,
+        robotCode: typeof robotCode === "string" ? robotCode : undefined,
+        text,
+        msgtype,
+        attachments,
+    };
+}
+function extractText(msgtype, textPayload, contentPayload) {
+    const directText = asString(textPayload.content) ?? asString(contentPayload.text);
+    if (directText)
+        return directText;
+    if (msgtype === "audio" || msgtype === "voice")
+        return asString(contentPayload.recognition) ?? "";
+    if (msgtype === "richText") {
+        const richText = contentPayload.richText;
+        if (!Array.isArray(richText))
+            return "";
+        return richText
+            .map((item) => asString(asRecord(item).text) ?? "")
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+function extractAttachments(msgtype, contentPayload, payload) {
+    const attachments = [];
+    const seen = new Set();
+    const append = (typeValue, item) => {
+        const type = normalizeAttachmentType(typeValue);
+        const downloadCode = asString(item.downloadCode) ?? asString(item.pictureDownloadCode);
+        if (!type || !downloadCode)
+            return;
+        if (seen.has(downloadCode))
+            return;
+        seen.add(downloadCode);
+        attachments.push({
+            type,
+            downloadCode,
+            fileName: asString(item.fileName) ?? asString(item.name),
+            duration: asNumber(item.duration),
+            recognition: asString(item.recognition),
+        });
+    };
+    append(msgtype, contentPayload);
+    append(msgtype, asRecord(payload));
+    if (msgtype === "richText" && Array.isArray(contentPayload.richText)) {
+        for (const item of contentPayload.richText) {
+            const record = asRecord(item);
+            append(asString(record.type) ?? "picture", record);
+        }
+    }
+    return attachments;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function asNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number.parseInt(value, 10);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function normalizeAttachmentType(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "picture" || normalized === "image")
+        return "picture";
+    if (normalized === "audio" || normalized === "voice")
+        return "audio";
+    if (normalized === "video")
+        return "video";
+    if (normalized === "file")
+        return "file";
+    return undefined;
+}
+function fileExtension(attachment, contentType) {
+    const fromName = attachment.fileName ? extname(attachment.fileName) : "";
+    if (fromName)
+        return fromName;
+    if (attachment.type === "picture") {
+        if (contentType?.includes("png"))
+            return ".png";
+        if (contentType?.includes("webp"))
+            return ".webp";
+        return ".jpg";
+    }
+    if (attachment.type === "audio")
+        return ".amr";
+    if (attachment.type === "video")
+        return ".mp4";
+    return ".bin";
+}
+function sanitizeFileName(name) {
+    const clean = basename(name).replace(/[^\w.-]+/g, "_");
+    return clean || "attachment";
+}
 export class DingTalkBot {
     config;
     client = null;
@@ -19,9 +178,11 @@ export class DingTalkBot {
             const message = this.parseMessage(data);
             if (!message) {
                 log.warn("Ignored invalid DingTalk payload");
+                log.debug(`downstream topic=${data.headers.topic} messageId=${data.headers.messageId} dataLen=${data.data.length}`);
                 this.ack(data.headers.messageId, { ignored: true });
                 return;
             }
+            log.info(`incoming conversation=${message.conversationId} msgtype=${message.msgtype} sender=${message.senderStaffId ?? message.senderId} textLen=${message.text.length} attachments=${message.attachments.length} hasWebhook=${Boolean(message.sessionWebhook)} hasRobotCode=${Boolean(message.robotCode)}`);
             try {
                 await onMessage(message);
                 this.ack(message.callbackId, { handled: true });
@@ -41,9 +202,12 @@ export class DingTalkBot {
     }
     async sendText(conversationId, content) {
         const webhook = this.webhooks.get(conversationId);
-        if (!webhook)
+        if (!webhook) {
+            log.warn(`No sessionWebhook for conversation=${conversationId}`);
             throw new Error(`No sessionWebhook for conversation: ${conversationId}`);
+        }
         const accessToken = await this.getAccessToken();
+        log.debug(`replying conversation=${conversationId} contentLen=${content.length}`);
         const res = await fetch(webhook, {
             method: "POST",
             headers: {
@@ -58,43 +222,135 @@ export class DingTalkBot {
         });
         if (!res.ok) {
             const text = await res.text();
+            log.warn(`reply failed conversation=${conversationId} status=${res.status} body=${safePreview(text)}`);
             throw new Error(`DingTalk reply failed: ${res.status} ${text}`);
         }
-        log.debug(`Sent DingTalk text to conversation=${conversationId}`);
+        log.debug(`reply ok conversation=${conversationId} status=${res.status}`);
+    }
+    async sendThinkingCard(message, content) {
+        if (!message.robotCode) {
+            await this.sendText(message.conversationId, content);
+            return { conversationId: message.conversationId, mode: "text" };
+        }
+        const cardBizId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const body = {
+            cardTemplateId: "StandardCard",
+            cardBizId,
+            outTrackId: cardBizId,
+            robotCode: message.robotCode,
+            cardData: buildStandardCardData("Codex - 执行中", content),
+        };
+        if (isSingleConversation(message.conversationType) && message.senderStaffId) {
+            body.singleChatReceiver = JSON.stringify({ userid: message.senderStaffId });
+        }
+        else {
+            body.openConversationId = message.conversationId;
+        }
+        try {
+            await this.callOpenApi("POST", "/v1.0/im/v1.0/robot/interactiveCards/send", body);
+            log.debug(`card sent conversation=${message.conversationId} cardBizId=${cardBizId}`);
+            return { conversationId: message.conversationId, mode: "card", cardBizId };
+        }
+        catch (err) {
+            log.warn(`card send failed, fallback to text: ${err instanceof Error ? err.message : String(err)}`);
+            await this.sendText(message.conversationId, content);
+            return { conversationId: message.conversationId, mode: "text" };
+        }
+    }
+    async updateReply(handle, title, content, options = { fallbackToText: true }) {
+        if (handle.mode !== "card" || !handle.cardBizId) {
+            await this.sendText(handle.conversationId, content);
+            return;
+        }
+        try {
+            await this.callOpenApi("PUT", "/v1.0/im/robots/interactiveCards", {
+                cardBizId: handle.cardBizId,
+                cardData: buildStandardCardData(title, content),
+            });
+            log.debug(`card updated conversation=${handle.conversationId} cardBizId=${handle.cardBizId}`);
+        }
+        catch (err) {
+            log.warn(`card update failed${options.fallbackToText === false ? "" : ", fallback to text"}: ${err instanceof Error ? err.message : String(err)}`);
+            if (options.fallbackToText !== false) {
+                await this.sendText(handle.conversationId, content);
+            }
+        }
+    }
+    async downloadAttachments(message) {
+        if (message.attachments.length === 0)
+            return [];
+        if (!message.robotCode) {
+            throw new Error("DingTalk media download requires robotCode, but this message did not include it");
+        }
+        const dir = resolve(this.config.codexWorkDir, ".oh-my-im", "media");
+        await mkdir(dir, { recursive: true });
+        const downloaded = [];
+        for (let index = 0; index < message.attachments.length; index += 1) {
+            const attachment = message.attachments[index];
+            const result = await this.callOpenApi("POST", "/v1.0/robot/messageFiles/download", {
+                downloadCode: attachment.downloadCode,
+                robotCode: message.robotCode,
+            });
+            const resultRecord = asRecord(result);
+            const downloadUrl = asString(resultRecord.downloadUrl) ?? asString(resultRecord.url);
+            if (!downloadUrl) {
+                throw new Error(`DingTalk media download response did not include downloadUrl: ${safePreview(result)}`);
+            }
+            const res = await fetch(downloadUrl, { signal: AbortSignal.timeout(60_000) });
+            if (!res.ok) {
+                throw new Error(`DingTalk media file download failed: ${res.status}`);
+            }
+            const contentType = res.headers.get("content-type") ?? undefined;
+            const nameBase = attachment.fileName ? sanitizeFileName(attachment.fileName) : attachment.type;
+            const withExt = extname(nameBase) ? nameBase : `${nameBase}${fileExtension(attachment, contentType)}`;
+            const path = join(dir, `${Date.now()}-${index}-${withExt}`);
+            const buffer = Buffer.from(await res.arrayBuffer());
+            await writeFile(path, buffer);
+            const size = buffer.byteLength;
+            downloaded.push({ ...attachment, path, size, contentType });
+            log.info(`downloaded attachment type=${attachment.type} path=${path} size=${size || "unknown"}`);
+        }
+        return downloaded;
     }
     parseMessage(data) {
-        let payload;
+        const message = parseDingTalkMessage(data);
+        if (!message)
+            return null;
+        this.webhooks.set(message.conversationId, message.sessionWebhook);
+        log.debug(`parsed conversation=${message.conversationId} sender=${message.senderStaffId ?? message.senderId} msgtype=${message.msgtype} textLen=${message.text.length} attachments=${message.attachments.length} webhookLen=${message.sessionWebhook.length}`);
+        return message;
+    }
+    async callOpenApi(method, path, body) {
+        const accessToken = await this.getAccessToken();
+        const res = await fetch(`https://api.dingtalk.com${path}`, {
+            method,
+            headers: {
+                "content-type": "application/json",
+                "x-acs-dingtalk-access-token": accessToken,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(30_000),
+        });
+        const text = await res.text();
+        if (!res.ok)
+            throw new Error(`DingTalk OpenAPI failed: ${res.status} ${text}`);
+        if (!text)
+            return {};
+        let parsed;
         try {
-            payload = JSON.parse(data.data);
+            parsed = JSON.parse(text);
         }
         catch {
-            log.warn("Failed to parse DingTalk payload");
-            return null;
+            return text;
         }
-        const conversationId = payload.conversationId;
-        const sessionWebhook = payload.sessionWebhook;
-        const senderStaffId = payload.senderStaffId;
-        const senderId = payload.senderId;
-        const msgtype = payload.msgtype;
-        const textPayload = payload.text;
-        const text = msgtype === "text" ? textPayload?.content?.trim() ?? "" : "";
-        if (typeof conversationId !== "string" ||
-            typeof sessionWebhook !== "string" ||
-            typeof senderId !== "string" ||
-            typeof msgtype !== "string") {
-            return null;
+        const code = parsed.errcode ?? parsed.errorCode ?? parsed.code;
+        const success = parsed.success;
+        if ((typeof code === "number" && code !== 0) ||
+            (typeof code === "string" && code && code !== "0" && code.toLowerCase() !== "ok") ||
+            success === false) {
+            throw new Error(`DingTalk OpenAPI business error: ${safePreview(parsed)}`);
         }
-        this.webhooks.set(conversationId, sessionWebhook);
-        return {
-            callbackId: data.headers.messageId,
-            conversationId,
-            sessionWebhook,
-            senderId,
-            senderStaffId: typeof senderStaffId === "string" ? senderStaffId : undefined,
-            senderNick: typeof payload.senderNick === "string" ? payload.senderNick : undefined,
-            text,
-            msgtype,
-        };
+        return parsed;
     }
     async getAccessToken() {
         if (!this.client)