openclaw-openagent 1.0.13 → 1.0.14

package/src/config/config-schema.ts

@@ -1,45 +0,0 @@
-/**
- * OpenAgent config schema — Zod-based runtime validation.
- *
- * This mirrors the JSON schema in openclaw.plugin.json but provides
- * type-safe runtime parsing via Zod.
- *
- * Uses direct zod dependency (same pattern as openclaw-weixin v2.1.1)
- * rather than openclaw/plugin-sdk/zod, which is only available in
- * OpenClaw >= ~2026.3.28 and would break on earlier supported hosts.
- */
-
-import { z } from 'zod';
-
-// ---------------------------------------------------------------------------
-// Zod config schema
-// ---------------------------------------------------------------------------
-
-const transportSchema = z.enum(['oasn', 'tim']).default('oasn');
-const updatePolicySchema = z.enum(['notify', 'auto', 'off']).optional();
-
-const openagentAccountSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-  transport: transportSchema.optional(),
-  agent_id: z.string().optional(),
-  api_key: z.string().optional(),
-  api_base: z.string().optional(),
-  access_api_base: z.string().optional(),
-  claim_url: z.string().optional(),
-  status: z.enum(['unregistered', 'unclaimed', 'claim_pending', 'claimed', 'credential_expired', 'unknown']).optional(),
-  registered_at: z.string().optional(),
-});
-
-/** Top-level openagent config schema. */
-export const OpenagentConfigSchema = openagentAccountSchema.extend({
-  transport: transportSchema.optional(),
-  api_base: z.string().optional(),
-  access_api_base: z.string().optional(),
-  update_policy: updatePolicySchema,
-  update_check: z.boolean().optional(),
-  auto_update: z.boolean().optional(),
-  update_channel: z.string().optional(),
-  update_dist_tag: z.string().optional(),
-  accounts: z.record(z.string(), openagentAccountSchema).optional(),
-});

package/src/messaging/aggregator.ts

@@ -1,120 +0,0 @@
-/**
- * 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';
-import type { RawMessage, ChannelDelta } from './types.js';
-
-export interface AggregatorConfig {
-  batchWindowMs: number;
-  maxBatchSize: number;
-}
-
-interface ChannelWindow {
-  channelId: string;
-  messages: RawMessage[];
-  timer: ReturnType<typeof setTimeout> | null;
-}
-
-export class WindowAggregator {
-  private windows = new Map<string, ChannelWindow>();
-  private config: AggregatorConfig;
-  public onDelta: ((delta: ChannelDelta) => void) | null = null;
-
-  constructor(config: Partial<AggregatorConfig> = {}) {
-    this.config = {
-      batchWindowMs: config.batchWindowMs || 60_000,
-      maxBatchSize: config.maxBatchSize || 20,
-    };
-  }
-
-  updateConfig(newConfig: Partial<AggregatorConfig>): void {
-    Object.assign(this.config, newConfig);
-  }
-
-  append(rawMessage: RawMessage): void {
-    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: string, reason: string): void {
-    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: ChannelDelta = {
-      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(): void {
-    for (const channelId of this.windows.keys()) {
-      this.flush(channelId, 'shutdown');
-    }
-  }
-
-  stop(): void {
-    for (const win of this.windows.values()) {
-      if (win.timer) clearTimeout(win.timer);
-    }
-    this.windows.clear();
-  }
-
-  private _getOrCreate(channelId: string): ChannelWindow {
-    let win = this.windows.get(channelId);
-    if (!win) {
-      win = { channelId, messages: [], timer: null };
-      this.windows.set(channelId, win);
-    }
-    return win;
-  }
-}

package/src/messaging/collector.ts

@@ -1,89 +0,0 @@
-/**
- * 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';
-import type { StateStore } from '../state/store.js';
-import type { WindowAggregator } from './aggregator.js';
-import type { RawMessage } from './types.js';
-
-export class Collector {
-  private aggregator: WindowAggregator;
-  private store: StateStore | null;
-  private agentId: string;
-  private _memSeen = new Set<string>();
-  private _memCleanupTimer: ReturnType<typeof setInterval> | null = null;
-
-  constructor(aggregator: WindowAggregator, store: StateStore | null = null, agentId = '') {
-    this.aggregator = aggregator;
-    this.store = store;
-    this.agentId = agentId;
-  }
-
-  ingest(rawMessage: RawMessage): void {
-    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: RawMessage[]): void {
-    for (const msg of rawMessages) {
-      this.ingest(msg);
-    }
-  }
-
-  private _hasSeen(messageId: string): boolean {
-    if (this.store) return this.store.hasSeen(messageId);
-    return this._memSeen.has(messageId);
-  }
-
-  private _markSeen(messageId: string, channelId: string): void {
-    if (this.store) {
-      this.store.markSeen(messageId, channelId);
-    } else {
-      this._memSeen.add(messageId);
-    }
-  }
-
-  startCleanup(intervalMs = 600_000): void {
-    if (this.store) return; // StateStore handles its own cleanup
-    this._memCleanupTimer = setInterval(() => {
-      this._memSeen.clear();
-    }, intervalMs);
-  }
-
-  stop(): void {
-    if (this._memCleanupTimer) {
-      clearInterval(this._memCleanupTimer);
-      this._memCleanupTimer = null;
-    }
-  }
-}

package/src/messaging/executor.ts

@@ -1,72 +0,0 @@
-/**
- * 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';
-import type { ChannelDelta } from './types.js';
-
-const execFileAsync = promisify(execFile);
-
-export class ActionExecutor {
-  private accountId = 'default';
-  private openclawBin = 'openclaw';
-
-  setAccountId(accountId: string): void {
-    this.accountId = accountId || 'default';
-  }
-
-  async handleDelta(delta: ChannelDelta): Promise<void> {
-    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 as Error).message}`);
-    }
-  }
-
-  private _formatDeltaText(delta: ChannelDelta): string {
-    const { channelId, messages, hasMention } = delta;
-    const mentionTag = hasMention ? ' ⚡ @mention' : '';
-
-    let messageSection: string;
-    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/src/messaging/inbound.ts

@@ -1,150 +0,0 @@
-/**
- * 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';
-
-// ── Types ──
-
-/** 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[];
-}
-
-// ── 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: RawPushMessage,
-  accountId: string,
-  extras?: InboundExtras,
-): OpenagentMsgContext {
-  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/src/messaging/index.ts

@@ -1,11 +0,0 @@
-/**
- * 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/src/messaging/mention-protocol.ts

@@ -1,94 +0,0 @@
-/**
- * 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
- */
-
-// ── Types ──
-
-export interface MentionMember {
-  id: string;
-  nick: string;
-}
-
-// ── Regex utility ──
-
-function escapeRegex(s: string): string {
-  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: MentionMember[],
-  selfId: string,
-): string {
-  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: string,
-  members: MentionMember[],
-  selfId: string,
-): string[] {
-  const results: string[] = [];
-  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;
-}