openclaw-openagent 1.0.1 → 1.0.3

package/dist/src/messaging/process-c2c-request.js

@@ -0,0 +1,445 @@
+/**
+ * Process C2C Request — Remote agent task request handler (T3)
+ *
+ * ⚠️  TIM-only 路径（v3.9+ 双轨抽象）
+ * ---------------------------------------------------------
+ * 本文件只在 transport='tim' 下被 AccountRuntime._connectTIM() 通过
+ * `this.client.on('c2c_request', ...)` 注册。OASN 路径下 AccountRuntime
+ * 不会监听 c2c_request 事件 —— OASN ClientAgent 是消费侧，不接收外来 Invocation，
+ * 远程 Agent 调用统一由发起方走 transport.sendTask / waitForTaskResult 完成。
+ *
+ * Handles incoming `c2c_request` events from c2c.ts (T1).
+ * Mirrors the process-message.ts pattern but for C2C task requests:
+ *
+ *   1. Parse request parameters (from, requestId, task, sessionMode)
+ *   2. Compute sessionKey (aligned with OpenClaw buildAgentPeerSessionKey)
+ *   3. Register onAgentEvent listener ({openagent_progress} prefix filter)
+ *   4. Build MsgContext (adapted for C2C, not group)
+ *   5. channelRuntime pipeline: resolveAgentRoute → finalize → record → dispatch
+ *   6. deliver callback routes kind="block" → progress, kind="final" → result
+ *   7. Unsubscribe onAgentEvent listener
+ *
+ * @see docs/specs/2026-06-16-oasn-transport-abstraction-design.md §4.2
+ * @see docs/products/orchestrator/specs/T3-remote-handler.md
+ * @see docs/products/orchestrator/specs/T1-c2c-infra.md §6.2 (c2c_request emit)
+ */
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import nodePath from 'node:path';
+import { ZipFile } from 'yazl';
+import { sendC2CCustomMessage } from '../tim/c2c.js';
+import { getOpenagentPluginRuntime } from '../runtime/plugin-runtime.js';
+import { registry } from '../runtime/registry.js';
+import { logger } from '../util/logger.js';
+// ── Progress prefix constant ──
+/**
+ * Marker prefix for tool progress messages.
+ * Remote developers add this prefix to onUpdate() calls to opt-in
+ * to progress forwarding via OpenAgent C2C.
+ *
+ * @see T3-remote-handler.md §9.1.2
+ */
+const PROGRESS_PREFIX = '{openagent_progress}';
+// ── Directory → ZIP helper ──
+/**
+ * Recursively zip a directory into a .zip file.
+ * Returns the path to the created zip file in /tmp/openclaw/openagent-media/.
+ *
+ * Uses yazl (pure JS, ~75KB) for cross-platform zip creation.
+ * The zip preserves directory structure with relative paths.
+ */
+function zipDirectory(dirPath) {
+    return new Promise((resolve, reject) => {
+        const dirName = nodePath.basename(dirPath);
+        const tmpDir = '/tmp/openclaw/openagent-media';
+        fs.mkdirSync(tmpDir, { recursive: true });
+        const zipPath = nodePath.join(tmpDir, `${Date.now()}-${dirName}.zip`);
+        const zipfile = new ZipFile();
+        // Recursively add all files
+        const addDir = (currentPath, prefix) => {
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = nodePath.join(currentPath, entry.name);
+                const arcPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    addDir(fullPath, arcPath);
+                }
+                else if (entry.isFile()) {
+                    zipfile.addFile(fullPath, arcPath);
+                }
+            }
+        };
+        addDir(dirPath, dirName);
+        zipfile.end();
+        const output = fs.createWriteStream(zipPath);
+        zipfile.outputStream.pipe(output);
+        output.on('close', () => {
+            logger.info(`[c2c-request] T4: zipped directory ${dirName}/ → ${zipPath} (${fs.statSync(zipPath).size} bytes)`);
+            resolve(zipPath);
+        });
+        output.on('error', reject);
+        zipfile.outputStream.on('error', reject);
+    });
+}
+// ── Core processing ──
+/**
+ * Process a single incoming C2C task request through the standard
+ * OpenClaw channelRuntime pipeline.
+ *
+ * This is the T3 equivalent of processOneMessage (process-message.ts).
+ * Fire-and-forget safe — errors are caught and result in an error C2C reply.
+ */
+export async function processC2CRequest(request, deps) {
+    const { from: fromUserId, payload, time } = request;
+    const { request_id: requestId, task, session_mode: sessionMode } = payload;
+    logger.info(`[c2c-request] Incoming task: from=${fromUserId} requestId=${requestId} mode=${sessionMode} taskLen=${task.length}`);
+    // ① Validate
+    if (!fromUserId || !requestId || !task) {
+        logger.error(`[c2c-request] Invalid request: missing required fields`);
+        await sendErrorResult(fromUserId, requestId, 'Invalid request: missing required fields');
+        return;
+    }
+    // ② Compute sessionKey — aligned with OpenClaw buildAgentPeerSessionKey
+    // Format: agent:{agentId}:{channel}:{peerKind}:{peerId}
+    // @see T1-c2c-infra.md §3.1 sessionKey naming convention
+    const agentId = 'main'; // Default agent ID; multi-agent is P1 (T3 §9.2)
+    // buildAgentPeerSessionKey (session-key-DAhnzjyr.js L211) lowercases peerId.
+    // Must match exactly for onAgentEvent sessionKey filtering to work.
+    const normalizedFrom = fromUserId.toLowerCase();
+    const sessionKey = sessionMode === 'run'
+        ? `agent:${agentId}:openagent:remote:${normalizedFrom}:run:${requestId}`
+        : `agent:${agentId}:openagent:remote:${normalizedFrom}`;
+    logger.debug(`[c2c-request] sessionKey=${sessionKey}`);
+    // ③ Register onAgentEvent listener for {openagent_progress} prefix
+    // Must be BEFORE dispatchReplyFromConfig — otherwise tool events are missed.
+    //
+    // Filter by runId (NOT sessionKey). OpenClaw sets isControlUiVisible=false
+    // for external channels like OpenAgent, which causes emitAgentEvent to strip
+    // sessionKey to undefined. runId is always preserved.
+    // @see audit/021-progress-pipeline-v1.md §4 (root cause)
+    const runId = randomUUID();
+    logger.debug(`[c2c-request] generated runId=${runId} for requestId=${requestId}`);
+    let unsubscribe = null;
+    try {
+        const runtime = getOpenagentPluginRuntime();
+        unsubscribe = runtime.events.onAgentEvent((evt) => {
+            if (evt.runId !== runId)
+                return;
+            if (evt.stream !== 'tool' || evt.data.phase !== 'update')
+                return;
+            // partialResult is AgentToolResult object: { content: [{ type: "text", text: "..." }] }
+            // Source: sanitizeToolResult (L173042-173071) returns same structure.
+            // OpenAgent toolResult() (types.ts L51-53): { content: [{ type: 'text', text }] }
+            const pr = evt.data.partialResult;
+            let raw;
+            if (pr && typeof pr === 'object' && Array.isArray(pr.content)) {
+                raw = pr.content.find((c) => c?.type === 'text')?.text ?? '';
+            }
+            else {
+                raw = String(pr ?? '');
+            }
+            if (!raw.startsWith(PROGRESS_PREFIX))
+                return; // No prefix → discard
+            const content = raw.slice(PROGRESS_PREFIX.length).trim();
+            if (!content)
+                return;
+            logger.info(`[c2c-request] Tool progress: requestId=${requestId} runId=${runId} content=${content.slice(0, 80)}`);
+            // Send via same TIM C2C path as deliver callback
+            void sendC2CCustomMessage(fromUserId, {
+                type: 'openagent_task_progress',
+                request_id: requestId,
+                content,
+            }).catch((err) => {
+                logger.error(`[c2c-request] Failed to send tool progress: ${err.message}`);
+            });
+        });
+    }
+    catch (err) {
+        // If PluginRuntime isn't available, continue without progress monitoring
+        logger.warn(`[c2c-request] Could not register onAgentEvent: ${err.message}`);
+    }
+    try {
+        const { channelRuntime, config, accountId } = deps;
+        // ④ Build MsgContext for C2C request
+        // NOT using timMessageToMsgContext — that's for group messages (ChatType='group').
+        // C2C requests are a different chat type.
+        const msgContext = {
+            // Message body
+            Body: task,
+            BodyForAgent: task,
+            RawBody: task,
+            CommandBody: task,
+            // Routing
+            From: fromUserId,
+            To: fromUserId, // C2C: destination is the sender (reply goes back to them)
+            AccountId: accountId,
+            // Sender info
+            SenderId: fromUserId,
+            SenderName: fromUserId,
+            // Conversation label
+            ConversationLabel: `openagent:remote:${fromUserId}`,
+            GroupSubject: '',
+            // Channel metadata
+            OriginatingChannel: 'openagent',
+            OriginatingTo: fromUserId,
+            MessageSid: `c2c:${requestId}`,
+            Timestamp: time * 1000, // TIM time is seconds, OpenClaw expects ms
+            Provider: 'openagent',
+            Surface: 'openagent',
+            ChatType: 'direct', // NOT 'group' — this is a C2C request
+            // Session
+            SessionKey: sessionKey,
+            // No mention, no history for C2C requests
+            WasMentioned: true, // Always process (no mention gating for C2C)
+        };
+        // ⑤ Agent routing
+        const route = channelRuntime.routing.resolveAgentRoute({
+            cfg: config,
+            channel: 'openagent',
+            accountId,
+            peer: { kind: 'remote', id: fromUserId },
+        });
+        logger.debug(`[c2c-request] route: agentId=${route.agentId ?? '(none)'} sessionKey=${route.sessionKey ?? '(none)'}`);
+        // Use our computed sessionKey, not the route's
+        // (route may return a different key for group-based routing)
+        msgContext.SessionKey = sessionKey;
+        // ⑤ Finalize inbound context
+        const finalized = channelRuntime.reply.finalizeInboundContext(msgContext);
+        // ⑤ Record inbound session
+        const storePath = channelRuntime.session.resolveStorePath(config.session?.store, { agentId: route.agentId || agentId });
+        await channelRuntime.session.recordInboundSession({
+            storePath,
+            sessionKey,
+            ctx: finalized,
+            updateLastRoute: {
+                sessionKey: route.mainSessionKey || sessionKey,
+                channel: 'openagent',
+                to: fromUserId,
+                accountId,
+            },
+            onRecordError: (err) => logger.error(`[c2c-request] recordInboundSession error: ${String(err)}`),
+        });
+        // ⑥ Create reply dispatcher + dispatch AI reply
+        const { dispatcher, replyOptions, markDispatchIdle } = channelRuntime.reply.createReplyDispatcherWithTyping({
+            deliver: async (deliverPayload, deliverMeta) => {
+                const text = deliverPayload.text ?? '';
+                const kind = deliverMeta?.kind;
+                if (kind === 'block') {
+                    // LLM streaming text → C2C progress (unchanged)
+                    if (!text)
+                        return;
+                    logger.debug(`[c2c-request] deliver block: requestId=${requestId} textLen=${text.length}`);
+                    await sendC2CCustomMessage(fromUserId, {
+                        type: 'openagent_task_progress',
+                        request_id: requestId,
+                        content: text,
+                    });
+                }
+                // kind="tool" → skip. Remote LLM will summarize tool data into natural language.
+                if (kind === 'final') {
+                    // ── T4: File detection + upload ──
+                    // Collect file paths from two sources:
+                    //   Path A: deliverPayload.mediaUrls (tool results, e.g. image_generate)
+                    //   Path B: {openagent_file} text markers (skill scripts)
+                    const filePaths = [];
+                    // Path A: structured mediaUrls from OpenClaw delivery pipeline
+                    if (deliverPayload.mediaUrls) {
+                        for (const u of deliverPayload.mediaUrls) {
+                            if (u)
+                                filePaths.push(u);
+                        }
+                    }
+                    if (deliverPayload.mediaUrl) {
+                        filePaths.push(deliverPayload.mediaUrl);
+                    }
+                    // Path B: {openagent_file} text markers
+                    let cleanText = text;
+                    const fileMarkerRegex = /\{openagent_file:([^}]+)\}/g;
+                    let match;
+                    while ((match = fileMarkerRegex.exec(text)) !== null) {
+                        const markerPath = match[1];
+                        filePaths.push(markerPath);
+                        cleanText = cleanText.replace(match[0], '').trim();
+                    }
+                    const tripDataPath = findTripCardDataFile(text);
+                    if (tripDataPath && !filePaths.includes(tripDataPath)) {
+                        filePaths.push(tripDataPath);
+                        logger.info(`[c2c-request] T4: attaching trip card data ${tripDataPath}`);
+                    }
+                    // Upload files via TIM C2C (TIMFileElem) — before sending text result
+                    let fileCount = 0;
+                    if (filePaths.length > 0) {
+                        logger.info(`[c2c-request] T4: ${filePaths.length} file(s) detected for requestId=${requestId}`);
+                        const rt = registry.getDefault();
+                        const chat = rt?.client?._chat;
+                        const types = rt?.client?._types;
+                        if (chat && types && rt?.client?.isReady) {
+                            const fs = await import('node:fs');
+                            const nodePath = await import('node:path');
+                            for (let filePath of filePaths) {
+                                try {
+                                    if (!fs.existsSync(filePath)) {
+                                        logger.warn(`[c2c-request] T4: file not found, skip: ${filePath}`);
+                                        continue;
+                                    }
+                                    // T4: If path is a directory, zip it first
+                                    if (fs.statSync(filePath).isDirectory()) {
+                                        logger.info(`[c2c-request] T4: path is directory, zipping: ${filePath}`);
+                                        filePath = await zipDirectory(filePath);
+                                    }
+                                    const buffer = fs.readFileSync(filePath);
+                                    const fileName = nodePath.basename(filePath);
+                                    const file = new File([buffer], fileName);
+                                    // TIM SDK expects payload.file to behave like an HTMLInputElement
+                                    // with a .files property (FileList). Node.js File doesn't have this.
+                                    // Wrap in a shim: { files: [File] } to satisfy SDK's internal check
+                                    // at createFileMessage → _isEmptyFileList(s.file.files).
+                                    const fileShim = { files: [file] };
+                                    logger.info(`[c2c-request] T4: uploading ${fileName} (${buffer.byteLength} bytes) to ${fromUserId}`);
+                                    const fileMsg = chat.createFileMessage({
+                                        to: fromUserId,
+                                        conversationType: types.CONV_C2C,
+                                        payload: { file: fileShim },
+                                    });
+                                    await chat.sendMessage(fileMsg);
+                                    fileCount++;
+                                    logger.info(`[c2c-request] T4: file sent OK: ${fileName}`);
+                                }
+                                catch (fileErr) {
+                                    logger.error(`[c2c-request] T4: file upload failed: ${fileErr.message} path=${filePath}`);
+                                }
+                            }
+                        }
+                        else {
+                            logger.warn(`[c2c-request] T4: TIM SDK not ready, skipping file upload`);
+                        }
+                    }
+                    // Send text result (with file_count for receiver coordination)
+                    const finalText = filePaths.length > 0 ? cleanText : text;
+                    if (finalText || fileCount > 0) {
+                        logger.info(`[c2c-request] deliver final: requestId=${requestId} textLen=${finalText.length} files=${fileCount}`);
+                        await sendC2CCustomMessage(fromUserId, {
+                            type: 'openagent_task_result',
+                            request_id: requestId,
+                            status: 'complete',
+                            content: finalText || '(file transfer)',
+                            file_count: fileCount,
+                        });
+                    }
+                }
+            },
+            onError: (err, info) => {
+                logger.error(`[c2c-request] reply ${info.kind} error: ${String(err)}`);
+            },
+        });
+        logger.debug(`[c2c-request] dispatching AI turn for requestId=${requestId}`);
+        try {
+            await channelRuntime.reply.withReplyDispatcher({
+                dispatcher,
+                run: () => channelRuntime.reply.dispatchReplyFromConfig({
+                    ctx: finalized,
+                    cfg: config,
+                    dispatcher,
+                    replyOptions: { ...replyOptions, runId },
+                }),
+            });
+            logger.info(`[c2c-request] AI turn completed for requestId=${requestId}`);
+        }
+        catch (err) {
+            logger.error(`[c2c-request] dispatchReplyFromConfig error: ${err.message}`);
+            await sendErrorResult(fromUserId, requestId, err.message);
+        }
+        finally {
+            markDispatchIdle();
+        }
+    }
+    catch (err) {
+        // Top-level error → send error result to requester
+        logger.error(`[c2c-request] Fatal error processing request: ${err.message}`);
+        await sendErrorResult(fromUserId, requestId, err.message);
+    }
+    finally {
+        // ⑦ Always unsubscribe onAgentEvent listener
+        if (unsubscribe) {
+            unsubscribe();
+            logger.debug(`[c2c-request] onAgentEvent listener unsubscribed for requestId=${requestId}`);
+        }
+    }
+}
+// ── Helpers ──
+/**
+ * Send an error result back to the requesting agent.
+ * Best-effort — if this fails, we just log.
+ */
+async function sendErrorResult(toUserId, requestId, errorMessage) {
+    try {
+        await sendC2CCustomMessage(toUserId, {
+            type: 'openagent_task_result',
+            request_id: requestId,
+            status: 'error',
+            content: errorMessage,
+        });
+    }
+    catch (err) {
+        logger.error(`[c2c-request] Failed to send error result: ${err.message}`);
+    }
+}
+function findTripCardDataFile(text) {
+    if (!text || !hasTripCardTags(text))
+        return null;
+    const candidates = getControlUiCandidates().flatMap((dir) => [
+        nodePath.join(dir, 'trip-card-data.json'),
+        nodePath.join(dir, 'ctrip-card-data.json'),
+    ]);
+    const cardIds = extractTripCardIds(text);
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        if (cardIds.length === 0 || tripDataMatches(candidate, cardIds)) {
+            return candidate;
+        }
+    }
+    logger.warn(`[c2c-request] Trip card tags found but no matching trip-card-data.json was available`);
+    return null;
+}
+function hasTripCardTags(text) {
+    return /<(?:sh_card|tr_card|i_card|la_card|bg_card|fr_card|time_data_card)>/i.test(text)
+        || /\[TRIP_CARDS_READY\]|\[CTRIP_CARDS_READY\]/.test(text);
+}
+function extractTripCardIds(text) {
+    const ids = new Set();
+    const re = /<(?:tr_card|i_card|la_card)>([\s\S]*?)<\/(?:tr_card|i_card|la_card)>/gi;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        const id = match[1]?.trim();
+        if (id)
+            ids.add(id);
+    }
+    return Array.from(ids);
+}
+function tripDataMatches(filePath, ids) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        return ids.some((id) => raw.includes(id));
+    }
+    catch {
+        return false;
+    }
+}
+function getControlUiCandidates() {
+    const dirs = new Set();
+    const argvEntry = process.argv[1] || '';
+    if (argvEntry) {
+        dirs.add(nodePath.join(nodePath.dirname(argvEntry), 'control-ui'));
+    }
+    dirs.add(nodePath.join(process.cwd(), 'dist', 'control-ui'));
+    dirs.add('/app/dist/control-ui');
+    return Array.from(dirs).filter((dir) => {
+        try {
+            return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/src/messaging/process-message.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Process Message — Core inbound dispatch pipeline
+ *
+ * ⚠️  TIM-only 路径（v3.9+ 双轨抽象）
+ * ---------------------------------------------------------
+ * 仅在 transport='tim' 下被 AccountRuntime._connectTIM() 通过
+ * `this.client.on('message', ...)` 注册。OASN 路径下没有 WebSocket 群聊消息，
+ * 该 pipeline 整体不参与运行。
+ *
+ * Replaces the old 4-module pipeline (Collector→Aggregator→Scheduler→Executor)
+ * with OpenClaw's standard channelRuntime dispatch:
+ *
+ *   1. Self-message filter
+ *   2. channelRuntime safety check
+ *   3. Append to channel history ring buffer
+ *   4. Fetch group context (name, skill)
+ *   5. TIM → MsgContext conversion (inbound.ts) with enriched context
+ *   6. Agent routing (channelRuntime.routing.resolveAgentRoute)
+ *   7. Finalize context (channelRuntime.reply.finalizeInboundContext)
+ *   8. Record session (channelRuntime.session.recordInboundSession)
+ *   9. Create reply dispatcher (channelRuntime.reply.createReplyDispatcherWithTyping)
+ *  10. Dispatch AI reply (channelRuntime.reply.dispatchReplyFromConfig)
+ *
+ * v3.4.0: Added InboundHistory ring buffer and GroupSystemPrompt/GroupSubject
+ *         injection to fix LLM NO_REPLY conversation breaks.
+ *         See: docs/audit/008-inbound-context-gap.md
+ *
+ * Reference: docs/reference/plugins/openclaw-weixin/src/messaging/process-message.ts
+ */
+import type { PluginRuntime } from 'openclaw/plugin-sdk/core';
+import type { RawPushMessage } from '../tim/client.js';
+import type { MentionMember } from './mention-protocol.js';
+/** Dependencies injected by the caller (AccountRuntime). */
+export interface ProcessMessageDeps {
+    accountId: string;
+    selfUserId: string;
+    config: Record<string, unknown>;
+    channelRuntime: PluginRuntime['channel'];
+    sendMessage: (channelId: string, text: string, atUserList?: string[]) => Promise<void>;
+    /** Fetch channel skill/rules (stored in TIM group notification). */
+    getChannelSkill?: (channelId: string) => Promise<string | null>;
+    /** Fetch channel display name. */
+    getGroupName?: (channelId: string) => Promise<string | null>;
+    /** Fetch a group-level custom field (AppDefinedData). */
+    getGroupCustomField?: (channelId: string, key: string) => Promise<string | null>;
+    /** Fetch group member list for mention protocol injection. */
+    getGroupMembers?: (channelId: string) => Promise<MentionMember[]>;
+    log: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug: (msg: string) => void;
+    };
+}
+/**
+ * Process a single inbound TIM push message through the standard
+ * OpenClaw channelRuntime pipeline.
+ *
+ * This function is fire-and-forget safe — errors are caught and logged,
+ * never propagated to crash the TIM event listener.
+ */
+export declare function processOneMessage(raw: RawPushMessage, deps: ProcessMessageDeps): Promise<void>;