@a2hmarket/a2hmarket 0.9.0 → 0.9.1

package/index.ts

@@ -142,6 +142,9 @@ export default {
       if (!a2hToolUsedSessions.has(sessionKey)) return;
       a2hToolUsedSessions.delete(sessionKey);
 
+      // Skip DM per-peer sessions — they have their own notification via deliver callback
+      if (sessionKey.includes(":a2hmarket:")) return;
+
       const content = (event as any)?.content ?? "";
       if (typeof content !== "string" || !content.trim()) return;
 

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.9.0",
+  "version": "0.9.1",
   "skills": [
     "./skills"
   ],

package/package.json

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

package/skills/a2hmarket/SKILL.md

@@ -8,6 +8,11 @@ version: 2.0.0
 
 A2H Market 是一个人类和 AI Agent 都可以使用的 AI 交易市场。你代理人类在市场中进行买卖交易。
 
+> ⚠️ **最高优先级规则：你是代理人，不是决策者。**
+> 涉及价格、报价、还价、创建订单、接受订单、支付、收款确认、交付验收等决定时，
+> **必须调用 `a2h_create_approval` 让人类确认，不得自行决定。**
+> 你只能自主回答帖子里已有的信息。其他一切需要人类拍板。
+
 **用三个概念理解你在市场里做的事：**
 
 | 概念 | 含义 | 角色 |

package/skills/a2hmarket/references/playbooks/reporting.md

@@ -13,10 +13,12 @@
 
 ## 关键节点即时汇报
 
-以下事件发生时，**立刻**在对话中告知人类用户，等待确认后再继续：
+以下事件发生时，**必须调用 `a2h_create_approval`** 创建审批，等待人类确认后再继续。**不要自行决定，不要只是"告知"——必须用审批工具。**
 
-| 事件 | 通知内容 | 人类需要做什么 |
+| 事件 | 审批内容 | 人类需要做什么 |
 |------|---------|--------------|
+| **对方报价 / 你需要报价** | 报价金额和条件 | 确认是否接受 / 确定报价 |
+| **对方还价** | 还价金额 vs 原价 | 接受 / 拒绝 / 继续还价 |
 | 订单创建（买方收到） | 订单信息、价格、条件 | 确认是否接受订单 |
 | 订单确认（卖方收到） | 买家已确认订单 | 知悉，进入付款阶段 |
 | **付款阶段（卖方）** | 买家已付款通知 | 确认是否真的收到款项 |
@@ -25,6 +27,19 @@
 | 帖子信息不足 | 对方提出帖子中未明确的条件 | 确认后更新帖子 |
 | 交易异常/破裂 | 异常原因 | 决定下一步 |
 
+**调用示例：**
+
+```
+a2h_create_approval(
+  peer_id: "ag_xxx",
+  question: "对方报价500元，是否接受？",
+  context: "对方昵称：小明\n1. 对方咨询PPT服务\n2. 你报价800\n3. 对方还价500",
+  options: ["接受", "拒绝", "还价"]
+)
+```
+
+调用后**不要回复对方**，等待 `[Human Approval Result]` 消息到达后再根据人类决定行动。
+
 
 ---
 

package/src/agent-service.ts

@@ -24,7 +24,7 @@ import { setApprovalConfig } from "./tools/approval.js";
 
 // ── MQTT Send Helper ─────────────────────────────────────────────────────
 
-async function mqttSendText(
+export async function mqttSendText(
   creds: { agentId: string; agentKey: string; apiUrl: string; mqttUrl: string },
   targetAgentId: string,
   text: string,

package/src/approval-store.ts

@@ -107,3 +107,9 @@ export function listPending(): Approval[] {
   evict();
   return [...approvals.values()].filter(a => a.status === "pending");
 }
+
+export function hasApprovedForPeer(peerId: string): boolean {
+  return [...approvals.values()].some(
+    a => a.peerId === peerId && (a.status === "approved" || a.status === "custom")
+  );
+}

package/src/tools/approval.ts

@@ -8,6 +8,7 @@ import { createApproval, resolveApproval, getApproval, markNotified, listPending
 import { notifyApproval, type NotifyLog } from "../notify.js";
 import { loadCredentials } from "../credentials.js";
 import { getA2HRuntime } from "../runtime.js";
+import { mqttSendText } from "../agent-service.js";
 
 let _cfg: OpenClawConfig | null = null;
 
@@ -65,8 +66,55 @@ export function registerApprovalTools(api: OpenClawPluginApi) {
       const approval = createApproval({ peerId, sessionKey, question, context, options });
 
       const creds = loadCredentials();
+      // Send notification card to human (visual notification)
       notifyApproval(approval, creds.agentId, notifyLog);
 
+      // Inject approval request into the human's channel session so the AI there has context
+      if (_cfg && creds.notify?.target) {
+        const runtime = getA2HRuntime();
+        const channelTarget = creds.notify.target;
+        const channel = creds.notify.channel;
+
+        const optionsLine = options.length > 0 ? `Options: ${options.join(" / ")}` : "";
+        const contextLine = context ? `Context: ${context}` : "";
+        const approvalMessage = [
+          `[A2H Market Pending Approval — DO NOT reply to this message. Wait for human's next message.]`,
+          `Approval ID: ${approval.id}`,
+          `From: ${peerId}`,
+          `Question: ${question}`,
+          contextLine,
+          optionsLine,
+          ``,
+          `INSTRUCTION: When the human sends their next message with a decision about this approval,`,
+          `call a2h_approval_response(approval_id='${approval.id}', decision='<the human's decision>').`,
+          `Do NOT reply to the human about this — just call the tool silently.`,
+        ].filter(Boolean).join("\n");
+
+        dispatchInboundDirectDmWithRuntime({
+          cfg: _cfg,
+          runtime,
+          channel,
+          channelLabel: channel,
+          accountId: "default",
+          peer: { kind: "direct", id: channelTarget },
+          senderId: "a2hmarket-system",
+          senderAddress: `a2hmarket:system`,
+          recipientAddress: `${channel}:${channelTarget}`,
+          conversationLabel: channelTarget,
+          rawBody: approvalMessage,
+          messageId: `approval_req_${approval.id}`,
+          timestamp: Date.now(),
+          commandAuthorized: true,
+          deliver: async () => {
+            // Don't send AI's response back — this is just context injection
+          },
+          onRecordError: () => {},
+          onDispatchError: () => {},
+        }).catch((err) => {
+          notifyLog.error(`approval feishu session inject failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      }
+
       return {
         result: JSON.stringify({
           approval_id: approval.id,
@@ -127,12 +175,28 @@ export function registerApprovalTools(api: OpenClawPluginApi) {
       if (_cfg) {
         const runtime = getA2HRuntime();
         const creds = loadCredentials();
-        const resultMessage = [
+        const resultParts = [
           `[Human Approval Result]`,
           `Approval: ${resolved.id}`,
+          `Peer: ${resolved.peerId}`,
           `Decision: ${decision}`,
+          ``,
           `Original question: ${resolved.question}`,
-        ].join("\n");
+        ];
+        if (resolved.context) {
+          resultParts.push(``, `Context: ${resolved.context}`);
+        }
+        if (resolved.options.length > 0) {
+          resultParts.push(`Options were: ${resolved.options.join(" / ")}`);
+        }
+        resultParts.push(
+          ``,
+          `Action required: Based on the human's decision above, proceed accordingly.`,
+          `If the decision is to accept/approve, continue with the next step (e.g., create order with a2h_order_create).`,
+          `If the decision is to reject, inform the counterparty.`,
+          `If the decision is custom text, follow the human's specific instruction.`,
+        );
+        const resultMessage = resultParts.join("\n");
 
         try {
           await dispatchInboundDirectDmWithRuntime({
@@ -150,7 +214,24 @@ export function registerApprovalTools(api: OpenClawPluginApi) {
             messageId: `approval_result_${resolved.id}`,
             timestamp: Date.now(),
             commandAuthorized: true,
-            deliver: async () => {},
+            deliver: async (payload) => {
+              // DM session AI may reply to counterparty after processing approval result
+              const replyText =
+                payload && typeof payload === "object" && "text" in payload
+                  ? String((payload as { text?: string }).text ?? "")
+                  : "";
+              if (!replyText.trim()) return;
+              // Send to counterparty via MQTT
+              try {
+                await mqttSendText(creds, resolved.peerId, replyText);
+                notifyLog.info(`approval follow-up sent to ${resolved.peerId}: ${replyText.slice(0, 80)}`);
+              } catch (err) {
+                notifyLog.error(`approval follow-up send failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+              // Notify human
+              const { notifyHuman: notifyH } = await import("../notify.js");
+              notifyH("reply", resolved.peerId, replyText.slice(0, 500), creds.agentId, notifyLog);
+            },
             onRecordError: (err) => {
               notifyLog.error(`approval dispatch record error: ${err instanceof Error ? err.message : String(err)}`);
             },

package/src/tools/order.ts

@@ -1,5 +1,6 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import type { A2HApiClient } from "../api-client.js";
+import { hasApprovedForPeer } from "../approval-store.js";
 
 export function registerOrderTools(api: OpenClawPluginApi, client: A2HApiClient) {
   api.registerTool({
@@ -19,6 +20,16 @@ export function registerOrderTools(api: OpenClawPluginApi, client: A2HApiClient)
       required: ["customer_id", "title", "content", "price_cent", "product_id", "order_type"],
     },
     execute: async (_toolCallId: string, params: Record<string, unknown>) => {
+      // Require human approval before creating orders
+      const customerId = params.customer_id as string;
+      if (!hasApprovedForPeer(customerId)) {
+        throw new Error(
+          "Cannot create order without human approval. " +
+          "Call a2h_create_approval(peer_id, question, context, options) first, " +
+          "wait for [Human Approval Result], then retry."
+        );
+      }
+
       const body = {
         providerId: client.agentId,
         customerId: params.customer_id,