@a2hmarket/a2hmarket 0.7.9 → 0.8.1

package/index.ts

@@ -36,6 +36,8 @@ import { registerAddressTools } from "./src/tools/address.js";
 import { registerDiscussionTools } from "./src/tools/discussion.js";
 import { registerPaymentTools } from "./src/tools/payment.js";
 import { registerTempoPaymentTools } from "./src/tools/tempo-payment.js";
+import { registerApprovalTools } from "./src/tools/approval.js";
+import { initApprovalStore } from "./src/approval-store.js";
 
 export default {
   id: "a2hmarket",
@@ -71,6 +73,7 @@ export default {
       // registerPaymentTools(api, apiClient);
       // registerTempoPaymentTools(api, apiClient, creds);
       registerInboxHistoryTool(api, apiClient);
+      registerApprovalTools(api);
     }
 
     // ── Auto-fix tools.alsoAllow at startup ──────────────────────
@@ -91,6 +94,7 @@ export default {
           "a2h_send", "a2h_inbox_history",
           "a2h_address_list", "a2h_address_create", "a2h_address_delete", "a2h_address_set_default",
           "a2h_discussion_publish", "a2h_discussion_reply", "a2h_discussion_list",
+          "a2h_create_approval", "a2h_approval_response", "a2h_approval_list",
         ];
         const missing = a2hTools.filter((t) => !alsoAllow.includes(t));
         if (missing.length > 0) {
@@ -171,6 +175,7 @@ export default {
 
         // Initialize stores with stateDir paths
         initReplyBridge(join(dataDir, "reply-bridge.json"));
+        initApprovalStore(join(dataDir, "approvals.json"));
         setLastChannelStore(new LastChannelStore(join(dataDir, "last-channel.json")));
 
         const serviceLog = {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "a2hmarket",
   "name": "A2H Market",
   "description": "A2H Market — AI agent marketplace with self-managed A2A messaging via MQTT.",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a2hmarket/a2hmarket",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "type": "module",
   "files": [
     "index.ts",

package/scripts/install.mjs

@@ -765,7 +765,7 @@ async function main() {
             if (target) {
               log(`    Detected Feishu user: ${CYAN}${target}${RESET}`);
             } else {
-              target = await prompt2.ask("Enter Feishu open_id (ou_xxx) or chat_id (oc_xxx)", "");
+              log(`    ${WARN} Could not auto-detect Feishu user. Notification will be configured after first Feishu message.`);
             }
           } else if (chosen.name === "discord") {
             target = await prompt2.ask("Enter Discord channel ID", "");

package/src/agent-service.ts

@@ -20,6 +20,7 @@ import { createSendTransport } from "./mqtt-transport.js";
 import { buildEnvelope, signEnvelope } from "./protocol.js";
 import { getA2HRuntime } from "./runtime.js";
 import { notifyHuman, notifyPayment, resolveNotifyConfig, type NotifyLog } from "./notify.js";
+import { setApprovalConfig } from "./tools/approval.js";
 
 // ── MQTT Send Helper ─────────────────────────────────────────────────────
 
@@ -64,6 +65,7 @@ export interface AgentServiceContext {
 export async function startAgentService(ctx: AgentServiceContext): Promise<void> {
   const creds = loadCredentials();
   const runtime = getA2HRuntime();
+  setApprovalConfig(ctx.cfg);
 
   const listener = new MqttListener(creds, {
     info: (m) => ctx.log.info(`[mqtt] ${m}`),

package/src/approval-store.ts

@@ -0,0 +1,109 @@
+// src/approval-store.ts
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+export interface Approval {
+  id: string;
+  peerId: string;
+  sessionKey: string;
+  question: string;
+  context?: string;
+  options: string[];
+  status: "pending" | "approved" | "rejected" | "custom";
+  response?: string;
+  createdAt: number;
+  resolvedAt?: number;
+  notified: boolean;
+}
+
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+let storePath: string | null = null;
+let approvals: Map<string, Approval> = new Map();
+
+export function initApprovalStore(filePath: string): void {
+  storePath = filePath;
+  mkdirSync(dirname(filePath), { recursive: true });
+  try {
+    const data = JSON.parse(readFileSync(filePath, "utf-8"));
+    if (Array.isArray(data)) {
+      for (const a of data) {
+        if (a?.id) approvals.set(a.id, a);
+      }
+    }
+  } catch {
+    // No persisted data yet
+  }
+  evict();
+}
+
+function persist(): void {
+  if (!storePath) return;
+  try {
+    writeFileSync(storePath, JSON.stringify([...approvals.values()], null, 2));
+  } catch {
+    // Best effort
+  }
+}
+
+function evict(): void {
+  const now = Date.now();
+  for (const [id, a] of approvals) {
+    if (now - a.createdAt > MAX_AGE_MS) approvals.delete(id);
+  }
+}
+
+function generateId(): string {
+  return `apr_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function createApproval(params: {
+  peerId: string;
+  sessionKey: string;
+  question: string;
+  context?: string;
+  options?: string[];
+}): Approval {
+  evict();
+  const approval: Approval = {
+    id: generateId(),
+    peerId: params.peerId,
+    sessionKey: params.sessionKey,
+    question: params.question,
+    context: params.context,
+    options: params.options ?? [],
+    status: "pending",
+    createdAt: Date.now(),
+    notified: false,
+  };
+  approvals.set(approval.id, approval);
+  persist();
+  return approval;
+}
+
+export function getApproval(id: string): Approval | null {
+  return approvals.get(id) ?? null;
+}
+
+export function resolveApproval(id: string, status: "approved" | "rejected" | "custom", response: string): Approval | null {
+  const approval = approvals.get(id);
+  if (!approval || approval.status !== "pending") return null;
+  approval.status = status;
+  approval.response = response;
+  approval.resolvedAt = Date.now();
+  persist();
+  return approval;
+}
+
+export function markNotified(id: string): void {
+  const approval = approvals.get(id);
+  if (approval) {
+    approval.notified = true;
+    persist();
+  }
+}
+
+export function listPending(): Approval[] {
+  evict();
+  return [...approvals.values()].filter(a => a.status === "pending");
+}

package/src/notify.ts

@@ -254,3 +254,57 @@ export async function notifyCustom(
     return;
   }
 }
+
+/**
+ * Send an approval request notification to the human.
+ * Content is AI-generated — question, context, and options are all composed by the AI.
+ */
+export function notifyApproval(
+  approval: { id: string; peerId: string; question: string; context?: string; options: string[] },
+  agentId: string,
+  log?: NotifyLog,
+): void {
+  const config = resolveNotifyConfig();
+  if (!config) {
+    log?.info("notify: no channel configured, skip approval notification");
+    return;
+  }
+
+  if (config.channel === "feishu" && config.appId && config.appSecret) {
+    const elements: FeishuCardElement[] = [
+      { tag: "markdown", content: `**From:** \`${approval.peerId}\`` },
+      { tag: "markdown", content: approval.question },
+    ];
+    if (approval.context) {
+      elements.push({ tag: "markdown", content: `📝 ${approval.context}` });
+    }
+    if (approval.options.length > 0) {
+      elements.push({ tag: "markdown", content: `**Options:** ${approval.options.join(" / ")}` });
+    }
+    elements.push({ tag: "markdown", content: `---\n*Approval ID: ${approval.id}*\n*我的A2H Agent: ${agentId}*` });
+
+    sendFeishuCard({
+      appId: config.appId,
+      appSecret: config.appSecret,
+      target: config.target,
+      title: "🔔 A2H Market · Approval Required",
+      titleColor: "orange",
+      elements,
+    })
+      .then((msgId) => log?.info(`approval card sent: ${msgId}`))
+      .catch((err) => log?.error(`approval card failed: ${err.message}`));
+    return;
+  }
+
+  if (config.channel === "discord" && config.botToken) {
+    const contextBlock = approval.context ? `\n\n📝 ${approval.context}` : "";
+    const optionsBlock = approval.options.length > 0 ? `\n\n**Options:** ${approval.options.join(" / ")}` : "";
+    const text = `**🔔 A2H Market · Approval Required**\n\nFrom: \`${approval.peerId}\`\n\n${approval.question}${contextBlock}${optionsBlock}\n\n---\n_Approval ID: ${approval.id}_`;
+    sendDiscordText(config.botToken, config.target, text)
+      .then((msgId) => log?.info(`approval discord sent: ${msgId}`))
+      .catch((err) => log?.error(`approval discord failed: ${err.message}`));
+    return;
+  }
+
+  log?.info(`notify: unsupported channel "${config.channel}" for approval`);
+}

package/src/tools/approval.ts

@@ -0,0 +1,205 @@
+// src/tools/approval.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import {
+  dispatchInboundDirectDmWithRuntime,
+} from "openclaw/plugin-sdk/channel-inbound";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { createApproval, resolveApproval, getApproval, markNotified, listPending } from "../approval-store.js";
+import { notifyApproval, type NotifyLog } from "../notify.js";
+import { loadCredentials } from "../credentials.js";
+import { getA2HRuntime } from "../runtime.js";
+
+let _cfg: OpenClawConfig | null = null;
+
+export function setApprovalConfig(cfg: OpenClawConfig): void {
+  _cfg = cfg;
+}
+
+export function registerApprovalTools(api: OpenClawPluginApi) {
+  const notifyLog: NotifyLog = {
+    info: (m) => api.logger.info(`[approval] ${m}`),
+    error: (m) => api.logger.error(`[approval] ${m}`),
+  };
+
+  api.registerTool({
+    name: "a2h_create_approval",
+    description:
+      "Create a human approval request. Use when you need the human to confirm a decision " +
+      "(e.g., accept/reject a price, confirm payment, authorize an action). " +
+      "Include a clear question, relevant context summary, and suggested options. " +
+      "The human will be notified and their response will be delivered back to this session. " +
+      "After calling this tool, WAIT — do not reply to the counterparty until you receive the approval result.",
+    parameters: {
+      type: "object",
+      properties: {
+        peer_id: {
+          type: "string",
+          description: "Counterparty agent ID this approval relates to",
+        },
+        question: {
+          type: "string",
+          description: "Clear question for the human (e.g., '对方报价500元，是否接受？')",
+        },
+        context: {
+          type: "string",
+          description: "Brief context summary for the human. Include counterparty nickname if known, and summarize the last 2-3 negotiation messages so the human understands the situation.",
+        },
+        options: {
+          type: "array",
+          items: { type: "string" },
+          description: "Suggested response options for the human (e.g., ['接受', '拒绝', '还价']). Leave empty for free-text response.",
+        },
+      },
+      required: ["peer_id", "question"],
+    },
+    execute: async (_toolCallId: string, params: Record<string, unknown>) => {
+      const peerId = params.peer_id as string;
+      const question = params.question as string;
+      const context = params.context as string | undefined;
+      const options = (params.options as string[]) ?? [];
+
+      if (!peerId) throw new Error("peer_id is required");
+      if (!question) throw new Error("question is required");
+
+      const sessionKey = `agent:main:a2hmarket:direct:${peerId}`;
+      const approval = createApproval({ peerId, sessionKey, question, context, options });
+
+      const creds = loadCredentials();
+      notifyApproval(approval, creds.agentId, notifyLog);
+
+      return {
+        result: JSON.stringify({
+          approval_id: approval.id,
+          status: "pending",
+          message: "Approval request sent to human. Wait for their response — it will be delivered to this session automatically.",
+        }, null, 2),
+      };
+    },
+  });
+
+  api.registerTool({
+    name: "a2h_approval_response",
+    description:
+      "Respond to a pending A2H Market approval request on behalf of the human. " +
+      "Use this when the human tells you their decision about a pending approval. " +
+      "The approval ID is shown in the notification card. " +
+      "The response will be automatically delivered to the trading session that requested it.",
+    parameters: {
+      type: "object",
+      properties: {
+        approval_id: {
+          type: "string",
+          description: "Approval ID (shown in the notification card, format: apr_xxx)",
+        },
+        decision: {
+          type: "string",
+          description: "Human's decision: 'approve'/'accept', 'reject'/'decline', or custom text (e.g., counter-offer '还价到450元')",
+        },
+      },
+      required: ["approval_id", "decision"],
+    },
+    execute: async (_toolCallId: string, params: Record<string, unknown>) => {
+      const approvalId = params.approval_id as string;
+      const decision = params.decision as string;
+
+      if (!approvalId) throw new Error("approval_id is required");
+      if (!decision) throw new Error("decision is required");
+
+      const existing = getApproval(approvalId);
+      if (!existing) {
+        throw new Error(`Approval ${approvalId} not found or expired`);
+      }
+      if (existing.status !== "pending") {
+        throw new Error(`Approval ${approvalId} already resolved: ${existing.status}`);
+      }
+
+      const status = decision === "approve" || decision === "accept" || decision === "接受"
+        ? "approved" as const
+        : decision === "reject" || decision === "decline" || decision === "拒绝"
+          ? "rejected" as const
+          : "custom" as const;
+
+      const resolved = resolveApproval(approvalId, status, decision);
+      if (!resolved) {
+        throw new Error(`Failed to resolve approval ${approvalId}`);
+      }
+
+      if (_cfg) {
+        const runtime = getA2HRuntime();
+        const creds = loadCredentials();
+        const resultMessage = [
+          `[Human Approval Result]`,
+          `Approval: ${resolved.id}`,
+          `Decision: ${decision}`,
+          `Original question: ${resolved.question}`,
+        ].join("\n");
+
+        try {
+          await dispatchInboundDirectDmWithRuntime({
+            cfg: _cfg,
+            runtime,
+            channel: "a2hmarket",
+            channelLabel: "A2H Market",
+            accountId: "default",
+            peer: { kind: "direct", id: resolved.peerId },
+            senderId: "system",
+            senderAddress: "a2hmarket:system",
+            recipientAddress: `a2hmarket:${creds.agentId}`,
+            conversationLabel: resolved.peerId,
+            rawBody: resultMessage,
+            messageId: `approval_result_${resolved.id}`,
+            timestamp: Date.now(),
+            commandAuthorized: true,
+            deliver: async () => {},
+            onRecordError: (err) => {
+              notifyLog.error(`approval dispatch record error: ${err instanceof Error ? err.message : String(err)}`);
+            },
+            onDispatchError: (err, info) => {
+              notifyLog.error(`approval dispatch ${info.kind} error: ${err instanceof Error ? err.message : String(err)}`);
+            },
+          });
+          markNotified(resolved.id);
+          notifyLog.info(`approval ${resolved.id} result injected into DM session for ${resolved.peerId}`);
+        } catch (err) {
+          notifyLog.error(`approval dispatch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else {
+        notifyLog.error("approval: config not set, cannot dispatch result to DM session");
+      }
+
+      return {
+        result: JSON.stringify({
+          approval_id: resolved.id,
+          status: resolved.status,
+          decision,
+          delivered: resolved.notified,
+        }, null, 2),
+      };
+    },
+  });
+
+  api.registerTool({
+    name: "a2h_approval_list",
+    description: "List pending A2H Market approval requests awaiting human response.",
+    parameters: {
+      type: "object",
+      properties: {},
+    },
+    execute: async () => {
+      const pending = listPending();
+      return {
+        result: JSON.stringify({
+          count: pending.length,
+          approvals: pending.map(a => ({
+            id: a.id,
+            peerId: a.peerId,
+            question: a.question,
+            context: a.context,
+            options: a.options,
+            createdAt: new Date(a.createdAt).toISOString(),
+          })),
+        }, null, 2),
+      };
+    },
+  });
+}