openclaw-openagent 1.0.1 → 1.0.3

package/dist/src/messaging/aggregator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * WindowAggregator — Message batching and ChannelDelta builder
+ *
+ * Buffers messages per channel with three flush triggers:
+ *   1. @mention → immediate flush
+ *   2. Buffer full → flush at maxBatchSize
+ *   3. Timer → flush after batchWindowMs
+ */
+import type { RawMessage, ChannelDelta } from './types.js';
+export interface AggregatorConfig {
+    batchWindowMs: number;
+    maxBatchSize: number;
+}
+export declare class WindowAggregator {
+    private windows;
+    private config;
+    onDelta: ((delta: ChannelDelta) => void) | null;
+    constructor(config?: Partial<AggregatorConfig>);
+    updateConfig(newConfig: Partial<AggregatorConfig>): void;
+    append(rawMessage: RawMessage): void;
+    flush(channelId: string, reason: string): void;
+    flushAll(): void;
+    stop(): void;
+    private _getOrCreate;
+}

package/dist/src/messaging/aggregator.js

@@ -0,0 +1,90 @@
+/**
+ * WindowAggregator — Message batching and ChannelDelta builder
+ *
+ * Buffers messages per channel with three flush triggers:
+ *   1. @mention → immediate flush
+ *   2. Buffer full → flush at maxBatchSize
+ *   3. Timer → flush after batchWindowMs
+ */
+import { logger } from '../util/logger.js';
+export class WindowAggregator {
+    windows = new Map();
+    config;
+    onDelta = null;
+    constructor(config = {}) {
+        this.config = {
+            batchWindowMs: config.batchWindowMs || 60_000,
+            maxBatchSize: config.maxBatchSize || 20,
+        };
+    }
+    updateConfig(newConfig) {
+        Object.assign(this.config, newConfig);
+    }
+    append(rawMessage) {
+        const channelId = rawMessage.channelId;
+        const win = this._getOrCreate(channelId);
+        win.messages.push(rawMessage);
+        // Immediate flush on @mention
+        if (rawMessage.mentionsMe) {
+            this.flush(channelId, 'mention');
+            return;
+        }
+        // Buffer full
+        if (win.messages.length >= this.config.maxBatchSize) {
+            this.flush(channelId, 'buffer_full');
+            return;
+        }
+        // Start timer if not running
+        if (!win.timer) {
+            win.timer = setTimeout(() => this.flush(channelId, 'timeout'), this.config.batchWindowMs);
+        }
+    }
+    flush(channelId, reason) {
+        const win = this.windows.get(channelId);
+        if (!win || win.messages.length === 0)
+            return;
+        const messages = win.messages.splice(0);
+        if (win.timer) {
+            clearTimeout(win.timer);
+            win.timer = null;
+        }
+        const hasMention = messages.some(m => m.mentionsMe);
+        const participants = [...new Set(messages.map(m => m.nick || m.from))];
+        const source = messages[0]?.source || 'push';
+        const delta = {
+            channelId,
+            channelName: channelId,
+            messageCount: messages.length,
+            participants,
+            hasMention,
+            urgency: hasMention ? 1.0 : Math.min(0.1 * messages.length, 0.9),
+            messages,
+            source,
+            flushReason: reason,
+        };
+        logger.debug(`[aggregator] FLUSH ch=${channelId} reason=${reason} msgs=${messages.length} mention=${hasMention}`);
+        if (this.onDelta) {
+            this.onDelta(delta);
+        }
+    }
+    flushAll() {
+        for (const channelId of this.windows.keys()) {
+            this.flush(channelId, 'shutdown');
+        }
+    }
+    stop() {
+        for (const win of this.windows.values()) {
+            if (win.timer)
+                clearTimeout(win.timer);
+        }
+        this.windows.clear();
+    }
+    _getOrCreate(channelId) {
+        let win = this.windows.get(channelId);
+        if (!win) {
+            win = { channelId, messages: [], timer: null };
+            this.windows.set(channelId, win);
+        }
+        return win;
+    }
+}

package/dist/src/messaging/collector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Collector — Message deduplication and distribution
+ *
+ * Deduplicates incoming messages using StateStore (or in-memory fallback).
+ * Agent's own messages are marked seen but NOT forwarded to aggregator.
+ *
+ * Authoritative writer for StateStore fields:
+ *   - last_visit: updated on ingest() success
+ *   - last_msg_seq: updated on ingest() when msg has sequence
+ */
+import type { StateStore } from '../state/store.js';
+import type { WindowAggregator } from './aggregator.js';
+import type { RawMessage } from './types.js';
+export declare class Collector {
+    private aggregator;
+    private store;
+    private agentId;
+    private _memSeen;
+    private _memCleanupTimer;
+    constructor(aggregator: WindowAggregator, store?: StateStore | null, agentId?: string);
+    ingest(rawMessage: RawMessage): void;
+    ingestBatch(rawMessages: RawMessage[]): void;
+    private _hasSeen;
+    private _markSeen;
+    startCleanup(intervalMs?: number): void;
+    stop(): void;
+}

package/dist/src/messaging/collector.js

@@ -0,0 +1,76 @@
+/**
+ * Collector — Message deduplication and distribution
+ *
+ * Deduplicates incoming messages using StateStore (or in-memory fallback).
+ * Agent's own messages are marked seen but NOT forwarded to aggregator.
+ *
+ * Authoritative writer for StateStore fields:
+ *   - last_visit: updated on ingest() success
+ *   - last_msg_seq: updated on ingest() when msg has sequence
+ */
+import { logger } from '../util/logger.js';
+export class Collector {
+    aggregator;
+    store;
+    agentId;
+    _memSeen = new Set();
+    _memCleanupTimer = null;
+    constructor(aggregator, store = null, agentId = '') {
+        this.aggregator = aggregator;
+        this.store = store;
+        this.agentId = agentId;
+    }
+    ingest(rawMessage) {
+        if (this._hasSeen(rawMessage.id)) {
+            logger.debug(`[collector] DEDUP skip id=${rawMessage.id}`);
+            return;
+        }
+        // Mark as seen
+        this._markSeen(rawMessage.id, rawMessage.channelId);
+        // Update StateStore: last_visit + last_msg_seq
+        if (this.store) {
+            this.store.updateLastVisit(rawMessage.channelId);
+            if (rawMessage.seq != null) {
+                this.store.updateLastMsgSeq(rawMessage.channelId, rawMessage.seq);
+            }
+        }
+        // Agent's own messages: mark seen but don't trigger agent turns
+        if (this.agentId && rawMessage.from === this.agentId) {
+            logger.debug(`[collector] SELF msg id=${rawMessage.id} (marked seen, no turn)`);
+            return;
+        }
+        logger.debug(`[collector] NEW msg id=${rawMessage.id} ch=${rawMessage.channelId} from=${rawMessage.nick}`);
+        this.aggregator.append(rawMessage);
+    }
+    ingestBatch(rawMessages) {
+        for (const msg of rawMessages) {
+            this.ingest(msg);
+        }
+    }
+    _hasSeen(messageId) {
+        if (this.store)
+            return this.store.hasSeen(messageId);
+        return this._memSeen.has(messageId);
+    }
+    _markSeen(messageId, channelId) {
+        if (this.store) {
+            this.store.markSeen(messageId, channelId);
+        }
+        else {
+            this._memSeen.add(messageId);
+        }
+    }
+    startCleanup(intervalMs = 600_000) {
+        if (this.store)
+            return; // StateStore handles its own cleanup
+        this._memCleanupTimer = setInterval(() => {
+            this._memSeen.clear();
+        }, intervalMs);
+    }
+    stop() {
+        if (this._memCleanupTimer) {
+            clearInterval(this._memCleanupTimer);
+            this._memCleanupTimer = null;
+        }
+    }
+}

package/dist/src/messaging/executor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ActionExecutor — Triggers OpenClaw agent turn via CLI
+ *
+ * Uses `openclaw agent` to inject inbound messages.
+ * Agent replies via openagent_send_message tool call.
+ */
+import type { ChannelDelta } from './types.js';
+export declare class ActionExecutor {
+    private accountId;
+    private openclawBin;
+    setAccountId(accountId: string): void;
+    handleDelta(delta: ChannelDelta): Promise<void>;
+    private _formatDeltaText;
+}

package/dist/src/messaging/executor.js

@@ -0,0 +1,59 @@
+/**
+ * ActionExecutor — Triggers OpenClaw agent turn via CLI
+ *
+ * Uses `openclaw agent` to inject inbound messages.
+ * Agent replies via openagent_send_message tool call.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { logger } from '../util/logger.js';
+const execFileAsync = promisify(execFile);
+export class ActionExecutor {
+    accountId = 'default';
+    openclawBin = 'openclaw';
+    setAccountId(accountId) {
+        this.accountId = accountId || 'default';
+    }
+    async handleDelta(delta) {
+        const text = this._formatDeltaText(delta);
+        logger.info(`[executor] INBOUND ch=${delta.channelId} msgs=${delta.messageCount} mention=${delta.hasMention}`);
+        try {
+            const args = [
+                'agent',
+                '--agent', 'main',
+                '--channel', 'openagent',
+                '--message', text,
+                '--session-id', `openagent:${delta.channelId}`,
+                '--json',
+            ];
+            const { stdout, stderr } = await execFileAsync(this.openclawBin, args, {
+                timeout: 120_000,
+                env: { ...process.env },
+            });
+            if (stderr) {
+                logger.debug(`[executor] stderr: ${stderr.substring(0, 500)}`);
+            }
+            if (stdout) {
+                logger.info(`[executor] Agent turn completed for ch=${delta.channelId}`);
+            }
+        }
+        catch (err) {
+            logger.error(`[executor] Agent turn failed: ${err.message}`);
+        }
+    }
+    _formatDeltaText(delta) {
+        const { channelId, messages, hasMention } = delta;
+        const mentionTag = hasMention ? ' ⚡ @mention' : '';
+        let messageSection;
+        if (messages.length === 1) {
+            const m = messages[0];
+            messageSection = `[Channel ${channelId}${mentionTag}] ${m.nick}: ${m.text}`;
+        }
+        else {
+            const summary = messages.map(m => `[${m.nick}] ${m.text}`).join('\n');
+            messageSection = `📬 ${messages.length} new messages in channel ${channelId}${mentionTag}:\n${summary}`;
+        }
+        const instruction = `[INSTRUCTION: Reply ONLY in channel ${channelId} using openagent_send_message. After calling the tool, respond with ONLY: NO_REPLY (this prevents your reply from leaking to the chat UI). Do NOT visit other channels. Do NOT send status reports. Just reply naturally to the conversation above, or stay silent if you have nothing to add.]`;
+        return `${messageSection}\n\n${instruction}`;
+    }
+}

package/dist/src/messaging/inbound.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Inbound — TIM push message → standard OpenClaw MsgContext conversion
+ *
+ * This module converts the TIM SDK's RawPushMessage into the standard
+ * MsgContext shape expected by channelRuntime.reply.dispatchReplyFromConfig().
+ *
+ * v3.4.0: Added BodyForAgent, InboundHistory, GroupSystemPrompt, GroupSubject,
+ *         ConversationLabel, Surface, SenderId, RawBody, CommandBody to match
+ *         the official plugin contract (Signal, LINE, Discord).
+ *         See: docs/audit/008-inbound-context-gap.md
+ *
+ * Reference: docs/reference/plugins/openclaw-weixin/src/messaging/inbound.ts
+ */
+import type { RawPushMessage } from '../tim/client.js';
+/** History entry for InboundHistory field. */
+export interface InboundHistoryEntry {
+    sender: string;
+    body: string;
+    timestamp: number;
+}
+/** Extra context not available from the raw TIM message alone. */
+export interface InboundExtras {
+    /** Group display name (fetched from TIM group profile) */
+    groupName?: string;
+    /** Group-level system prompt (from channel skill / notification field) */
+    groupSystemPrompt?: string;
+    /** Recent message history for this channel */
+    inboundHistory?: InboundHistoryEntry[];
+}
+/**
+ * Standard inbound context for the OpenClaw pipeline.
+ * Field names MUST match the OpenClaw MsgContext contract.
+ */
+export interface OpenagentMsgContext {
+    /** Message text body (may include envelope in future) */
+    Body: string;
+    /** Current message original text — LLM prompt main body */
+    BodyForAgent: string;
+    /** Raw message body for command detection */
+    RawBody: string;
+    /** Command detection text */
+    CommandBody: string;
+    /** Sender user ID */
+    From: string;
+    /** Destination (channel ID for group chats) */
+    To: string;
+    /** Account ID this message belongs to */
+    AccountId: string;
+    /** Sender machine ID */
+    SenderId: string;
+    /** Sender display name */
+    SenderName: string;
+    /** Human-readable conversation label */
+    ConversationLabel: string;
+    /** Group name / subject */
+    GroupSubject: string;
+    /** Channel plugin identifier */
+    OriginatingChannel: 'openagent';
+    /** Original destination identifier */
+    OriginatingTo: string;
+    /** Unique message ID */
+    MessageSid: string;
+    /** Message timestamp (ms) */
+    Timestamp?: number;
+    /** Provider identifier */
+    Provider: 'openagent';
+    /** Platform surface identifier */
+    Surface: 'openagent';
+    /** Chat type: OpenAgent is group-only */
+    ChatType: 'group';
+    /** Whether the message @mentioned our agent */
+    WasMentioned?: boolean;
+    /** Session key override (set after resolveAgentRoute) */
+    SessionKey?: string;
+    /** Whether sender is authorized for slash commands */
+    CommandAuthorized?: boolean;
+    /** Group-level system prompt (channel skill / rules) */
+    GroupSystemPrompt?: string;
+    /** Recent message history for this channel */
+    InboundHistory?: InboundHistoryEntry[];
+}
+/**
+ * Convert a TIM RawPushMessage to the standard MsgContext.
+ *
+ * Mapping:
+ *   raw.text       → Body, BodyForAgent, RawBody, CommandBody
+ *   raw.from       → From, SenderId
+ *   raw.channelId  → To, OriginatingTo
+ *   raw.nick       → SenderName
+ *   raw.id         → MessageSid
+ *   raw.time       → Timestamp
+ *   raw.mentionsMe → WasMentioned
+ *   extras.groupName         → GroupSubject, ConversationLabel
+ *   extras.groupSystemPrompt → GroupSystemPrompt
+ *   extras.inboundHistory    → InboundHistory
+ */
+export declare function timMessageToMsgContext(raw: RawPushMessage, accountId: string, extras?: InboundExtras): OpenagentMsgContext;

package/dist/src/messaging/inbound.js

@@ -0,0 +1,63 @@
+/**
+ * Inbound — TIM push message → standard OpenClaw MsgContext conversion
+ *
+ * This module converts the TIM SDK's RawPushMessage into the standard
+ * MsgContext shape expected by channelRuntime.reply.dispatchReplyFromConfig().
+ *
+ * v3.4.0: Added BodyForAgent, InboundHistory, GroupSystemPrompt, GroupSubject,
+ *         ConversationLabel, Surface, SenderId, RawBody, CommandBody to match
+ *         the official plugin contract (Signal, LINE, Discord).
+ *         See: docs/audit/008-inbound-context-gap.md
+ *
+ * Reference: docs/reference/plugins/openclaw-weixin/src/messaging/inbound.ts
+ */
+// ── Conversion ──
+/**
+ * Convert a TIM RawPushMessage to the standard MsgContext.
+ *
+ * Mapping:
+ *   raw.text       → Body, BodyForAgent, RawBody, CommandBody
+ *   raw.from       → From, SenderId
+ *   raw.channelId  → To, OriginatingTo
+ *   raw.nick       → SenderName
+ *   raw.id         → MessageSid
+ *   raw.time       → Timestamp
+ *   raw.mentionsMe → WasMentioned
+ *   extras.groupName         → GroupSubject, ConversationLabel
+ *   extras.groupSystemPrompt → GroupSystemPrompt
+ *   extras.inboundHistory    → InboundHistory
+ */
+export function timMessageToMsgContext(raw, accountId, extras) {
+    const senderName = raw.nick || raw.from;
+    const groupName = extras?.groupName || raw.channelId;
+    return {
+        // ── Message body (4 variants per official contract) ──
+        Body: raw.text,
+        BodyForAgent: raw.text,
+        RawBody: raw.text,
+        CommandBody: raw.text,
+        // ── Routing ──
+        From: raw.from,
+        To: raw.channelId,
+        AccountId: accountId,
+        // ── Sender info ──
+        SenderId: raw.from,
+        SenderName: senderName,
+        // ── Group info ──
+        ConversationLabel: groupName,
+        GroupSubject: groupName,
+        // ── Channel metadata ──
+        OriginatingChannel: 'openagent',
+        OriginatingTo: raw.channelId,
+        MessageSid: raw.id,
+        Timestamp: raw.time,
+        Provider: 'openagent',
+        Surface: 'openagent',
+        ChatType: 'group',
+        // ── Flags ──
+        WasMentioned: raw.mentionsMe,
+        // ── Enriched context (from extras) ──
+        GroupSystemPrompt: extras?.groupSystemPrompt || undefined,
+        InboundHistory: extras?.inboundHistory,
+    };
+}

package/dist/src/messaging/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Messaging — Module barrel export
+ *
+ * v3.2.0: New channelRuntime-based pipeline (inbound + process-message).
+ * Legacy modules (collector, aggregator, scheduler, executor) are retained
+ * on disk but no longer exported or referenced.
+ */
+export { timMessageToMsgContext, type OpenagentMsgContext } from './inbound.js';
+export { processOneMessage, type ProcessMessageDeps } from './process-message.js';
+export type { RawMessage, ChannelDelta, HistoryMessage } from './types.js';

package/dist/src/messaging/index.js

@@ -0,0 +1,9 @@
+/**
+ * Messaging — Module barrel export
+ *
+ * v3.2.0: New channelRuntime-based pipeline (inbound + process-message).
+ * Legacy modules (collector, aggregator, scheduler, executor) are retained
+ * on disk but no longer exported or referenced.
+ */
+export { timMessageToMsgContext } from './inbound.js';
+export { processOneMessage } from './process-message.js';

package/dist/src/messaging/mention-protocol.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Mention Protocol — Bot-to-Bot communication in mention-only groups
+ *
+ * Pure function module — no side effects, no shared state.
+ *
+ * When a group has gm_req_mention=1, bots need to:
+ * 1. Know the group's "social rule" (must @-mention to trigger others)
+ * 2. Know who's in the group (member list)
+ * 3. Have their text-level @mentions translated to TIM protocol-level atUserList
+ *
+ * See: docs/audit/012-mention-mode-bot-to-bot-v3.4.4.md
+ */
+export interface MentionMember {
+    id: string;
+    nick: string;
+}
+/**
+ * Build the mention protocol prompt to inject into GroupSystemPrompt.
+ * Tells the AI: this group is mention-only, here are the members,
+ * you must @mention them to communicate.
+ *
+ * Returns empty string if no other members exist.
+ */
+export declare function buildMentionPrompt(members: MentionMember[], selfId: string): string;
+/**
+ * Extract @-mention targets from AI output text.
+ *
+ * Strategy: iterate the known member list and search for each nick
+ * in the text. This is more robust than parsing @-tokens from text,
+ * because it handles:
+ *   - Space after @:  "@ 投资人Bot"
+ *   - Case mismatch:  "@投资人bot"
+ *   - Trailing punct:  "@投资人Bot，你好"
+ *   - Multiple @:     "@BotA @BotB hi"
+ *
+ * Only matches when @ prefix is present — mentioning a name without @
+ * (e.g. "投资人Bot说得对") does NOT trigger a match.
+ *
+ * Returns an array of userIDs suitable for TIM createTextAtMessage.
+ * Returns empty array if no matches found.
+ */
+export declare function extractAtTargets(text: string, members: MentionMember[], selfId: string): string[];

package/dist/src/messaging/mention-protocol.js

@@ -0,0 +1,74 @@
+/**
+ * Mention Protocol — Bot-to-Bot communication in mention-only groups
+ *
+ * Pure function module — no side effects, no shared state.
+ *
+ * When a group has gm_req_mention=1, bots need to:
+ * 1. Know the group's "social rule" (must @-mention to trigger others)
+ * 2. Know who's in the group (member list)
+ * 3. Have their text-level @mentions translated to TIM protocol-level atUserList
+ *
+ * See: docs/audit/012-mention-mode-bot-to-bot-v3.4.4.md
+ */
+// ── Regex utility ──
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// ── Prompt injection ──
+/**
+ * Build the mention protocol prompt to inject into GroupSystemPrompt.
+ * Tells the AI: this group is mention-only, here are the members,
+ * you must @mention them to communicate.
+ *
+ * Returns empty string if no other members exist.
+ */
+export function buildMentionPrompt(members, selfId) {
+    const others = members.filter(m => m.id !== selfId);
+    if (others.length === 0)
+        return '';
+    const memberList = others
+        .map(m => `- ${m.nick} (mention as: @${m.nick})`)
+        .join('\n');
+    return [
+        '[GROUP COMMUNICATION PROTOCOL]',
+        'This group uses mention-only mode.',
+        'Your messages will ONLY be seen by members you @-mention.',
+        'To mention someone, write @their_name in your message.',
+        '',
+        'Group members:',
+        memberList,
+        '',
+        `Example: "@${others[0].nick} what do you think?"`,
+        '[/GROUP COMMUNICATION PROTOCOL]',
+    ].join('\n');
+}
+// ── Text → atUserList extraction ──
+/**
+ * Extract @-mention targets from AI output text.
+ *
+ * Strategy: iterate the known member list and search for each nick
+ * in the text. This is more robust than parsing @-tokens from text,
+ * because it handles:
+ *   - Space after @:  "@ 投资人Bot"
+ *   - Case mismatch:  "@投资人bot"
+ *   - Trailing punct:  "@投资人Bot，你好"
+ *   - Multiple @:     "@BotA @BotB hi"
+ *
+ * Only matches when @ prefix is present — mentioning a name without @
+ * (e.g. "投资人Bot说得对") does NOT trigger a match.
+ *
+ * Returns an array of userIDs suitable for TIM createTextAtMessage.
+ * Returns empty array if no matches found.
+ */
+export function extractAtTargets(text, members, selfId) {
+    const results = [];
+    for (const member of members) {
+        if (member.id === selfId)
+            continue;
+        const pattern = new RegExp(`@\\s*${escapeRegex(member.nick)}`, 'i');
+        if (pattern.test(text)) {
+            results.push(member.id);
+        }
+    }
+    return results;
+}

package/dist/src/messaging/process-c2c-request.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 type { PluginRuntime } from 'openclaw/plugin-sdk/core';
+/** Parsed task request payload (from c2c.ts L267) */
+interface C2CTaskRequest {
+    type: 'openagent_task_request';
+    request_id: string;
+    task: string;
+    session_mode: string;
+}
+/** Incoming c2c_request event shape (emitted by c2c.ts initC2CHandler) */
+export interface C2CRequestEvent {
+    from: string;
+    payload: C2CTaskRequest;
+    time: number;
+}
+/** Dependencies injected by AccountRuntime._connectTIM() */
+export interface ProcessC2CRequestDeps {
+    accountId: string;
+    selfUserId: string;
+    config: Record<string, unknown>;
+    channelRuntime: PluginRuntime['channel'];
+}
+/**
+ * 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 declare function processC2CRequest(request: C2CRequestEvent, deps: ProcessC2CRequestDeps): Promise<void>;
+export {};