@agentchatme/openclaw 0.7.7 → 0.7.81

package/dist/setup-entry.cjs

@@ -10,15 +10,40 @@ var zod = require('zod');
 var channelLifecycle = require('openclaw/plugin-sdk/channel-lifecycle');
 var pino = require('pino');
 var ws = require('ws');
-var directDm = require('openclaw/plugin-sdk/direct-dm');
 var inboundEnvelope = require('openclaw/plugin-sdk/inbound-envelope');
 var inboundReplyDispatch = require('openclaw/plugin-sdk/inbound-reply-dispatch');
+var fs2 = require('fs');
+var os = require('os');
+var path2 = require('path');
+var readEnv_js$1 = require('./credentials/read-env.cjs');
 var agentchatme = require('agentchatme');
+var simpleCompletionRuntime = require('openclaw/plugin-sdk/simple-completion-runtime');
 var typebox = require('@sinclair/typebox');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
 var pino__default = /*#__PURE__*/_interopDefault(pino);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 
 // src/channel.setup.ts
 
@@ -271,9 +296,9 @@ async function registerAgentVerify(input, opts = {}) {
   }
   return { ok: false, reason: "server-error", status: res.status, message };
 }
-async function post(path, body, opts) {
+async function post(path3, body, opts) {
   const base = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
-  const url = `${base}${path}`;
+  const url = `${base}${path3}`;
   const controller = new AbortController();
   const fetchImpl = opts.fetch ?? fetch;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -908,9 +933,9 @@ function createLogger(options) {
 function buildRedactPaths(keys) {
   const prefixes = ["", "config.", "headers.", "context.", "req.headers.", "res.headers."];
   const paths = [];
-  for (const key of keys) {
+  for (const key2 of keys) {
     for (const prefix of prefixes) {
-      paths.push(`${prefix}${key}`);
+      paths.push(`${prefix}${key2}`);
     }
   }
   paths.push(...keys.map((k) => `*.${k}`));
@@ -1726,7 +1751,7 @@ function normalizeGroupDeleted(frame) {
 
 // src/retry.ts
 function defaultSleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function retryWithPolicy(fn, policy) {
   const random = policy.random ?? Math.random;
@@ -1854,7 +1879,7 @@ var CircuitBreaker = class {
 };
 
 // src/version.ts
-var PACKAGE_VERSION = "0.7.7";
+var PACKAGE_VERSION = "0.7.81";
 
 // src/outbound.ts
 var DEFAULT_RETRY_POLICY = {
@@ -2070,11 +2095,11 @@ var OutboundAdapter = class {
         `outbound queue full (${this.queue.length}) \u2014 shedding load`
       );
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       this.queue.push(() => {
         this.inFlight++;
         this.metrics.setInFlightDepth(this.inFlight);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -2150,10 +2175,10 @@ var AgentchatChannelRuntime = class {
   stop(deadlineMs) {
     if (this.stopPromise) return this.stopPromise;
     const deadline = deadlineMs ?? this.now() + 5e3;
-    this.stopPromise = new Promise((resolve) => {
+    this.stopPromise = new Promise((resolve2) => {
       const off = this.ws.on("closed", () => {
         off();
-        resolve();
+        resolve2();
       });
       this.ws.stop(deadline);
     });
@@ -2383,6 +2408,457 @@ function unregisterRuntime(accountId, deadlineMs = Date.now() + 5e3) {
 function getRuntime(accountId) {
   return registry.get(accountId)?.runtime;
 }
+function resolveWorkspaceDir(cfg) {
+  const configured = cfg?.agents?.defaults?.workspace;
+  if (typeof configured === "string" && configured.trim().length > 0) {
+    return path2__namespace.resolve(configured);
+  }
+  const profile = readEnv_js$1.readOpenClawProfileFromEnv();
+  if (profile) {
+    return path2__namespace.join(os__namespace.homedir(), ".openclaw", `workspace-${profile}`);
+  }
+  return path2__namespace.join(os__namespace.homedir(), ".openclaw", "workspace");
+}
+
+// src/binding/thread-closures.ts
+var instances = /* @__PURE__ */ new Map();
+function fallbackWorkspaceDir() {
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  if (profile && profile.toLowerCase() !== "default") {
+    return path2__namespace.default.join(os__namespace.default.homedir(), ".openclaw", `workspace-${profile}`);
+  }
+  return path2__namespace.default.join(os__namespace.default.homedir(), ".openclaw", "workspace");
+}
+function resolveStatePath(cfg, accountId) {
+  const workspaceDir = typeof cfg === "object" && cfg !== null ? resolveWorkspaceDir(cfg) : fallbackWorkspaceDir();
+  return path2__namespace.default.join(workspaceDir, `.agentchat-closed-threads-${accountId}.json`);
+}
+var ThreadClosures = class {
+  filePath;
+  closed = /* @__PURE__ */ new Map();
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.load();
+  }
+  isClosed(conversationId) {
+    return this.closed.has(conversationId);
+  }
+  close(conversationId, reason) {
+    const record = {
+      conversationId,
+      closedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: reason?.trim() ? reason.trim() : null
+    };
+    this.closed.set(conversationId, record);
+    this.save();
+    return record;
+  }
+  reopen(conversationId) {
+    const existed = this.closed.delete(conversationId);
+    if (existed) this.save();
+    return existed;
+  }
+  list() {
+    return [...this.closed.values()].sort((a, b) => b.closedAt.localeCompare(a.closedAt));
+  }
+  load() {
+    if (!fs2__default.default.existsSync(this.filePath)) return;
+    try {
+      const raw = JSON.parse(fs2__default.default.readFileSync(this.filePath, "utf8"));
+      if (!Array.isArray(raw)) return;
+      for (const entry of raw) {
+        if (!entry || typeof entry !== "object") continue;
+        const conversationId = entry.conversationId;
+        const closedAt = entry.closedAt;
+        const reason = entry.reason;
+        if (typeof conversationId !== "string" || typeof closedAt !== "string") continue;
+        this.closed.set(conversationId, {
+          conversationId,
+          closedAt,
+          reason: typeof reason === "string" ? reason : null
+        });
+      }
+    } catch {
+      this.closed = /* @__PURE__ */ new Map();
+    }
+  }
+  save() {
+    fs2__default.default.mkdirSync(path2__namespace.default.dirname(this.filePath), { recursive: true });
+    const payload = JSON.stringify(this.list(), null, 2);
+    const tempPath = `${this.filePath}.tmp`;
+    fs2__default.default.writeFileSync(tempPath, payload, "utf8");
+    fs2__default.default.renameSync(tempPath, this.filePath);
+  }
+};
+function getThreadClosures(cfg, accountId) {
+  const filePath = resolveStatePath(cfg, accountId);
+  const existing = instances.get(filePath);
+  if (existing) return existing;
+  const created = new ThreadClosures(filePath);
+  instances.set(filePath, created);
+  return created;
+}
+var cache = /* @__PURE__ */ new Map();
+function getClient({ accountId, config, options }) {
+  const existing = cache.get(accountId);
+  if (existing && existing.apiKey === config.apiKey && existing.apiBase === config.apiBase) {
+    return existing.client;
+  }
+  const client = new agentchatme.AgentChatClient({
+    apiKey: config.apiKey,
+    baseUrl: config.apiBase,
+    ...options
+  });
+  cache.set(accountId, {
+    client,
+    apiKey: config.apiKey,
+    apiBase: config.apiBase
+  });
+  return client;
+}
+function disposeClient(accountId) {
+  cache.delete(accountId);
+}
+
+// src/binding/send-tracker.ts
+var lastSendByKey = /* @__PURE__ */ new Map();
+var MAX_TRACKED = 512;
+function key(accountId, conversationId) {
+  return `${accountId}\0${conversationId}`;
+}
+function recordAgentSend(accountId, conversationId, atMs = Date.now()) {
+  if (!conversationId) return;
+  const k = key(accountId, conversationId);
+  lastSendByKey.delete(k);
+  lastSendByKey.set(k, atMs);
+  if (lastSendByKey.size > MAX_TRACKED) {
+    const oldest = lastSendByKey.keys().next().value;
+    if (oldest !== void 0) lastSendByKey.delete(oldest);
+  }
+}
+function hasAgentSendSince(accountId, conversationId, sinceMs) {
+  const at = lastSendByKey.get(key(accountId, conversationId));
+  return at !== void 0 && at >= sinceMs;
+}
+
+// src/binding/reply-gate.ts
+var DEFAULT_GATE_MAX_TOKENS = 256;
+var MAX_HISTORY_TURNS = 12;
+var CADENCE_WINDOW_SECONDS = 60;
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "open_request",
+  "new_info",
+  "goal_followup",
+  "closing",
+  "acknowledgement",
+  "not_addressed",
+  "no_action_needed",
+  "spam",
+  "other"
+]);
+var REPLY_TOKENS = /* @__PURE__ */ new Set(["reply", "yes", "true", "respond"]);
+var NO_REPLY_TOKENS = /* @__PURE__ */ new Set([
+  "no_reply",
+  "no-reply",
+  "noreply",
+  "no",
+  "false",
+  "silent",
+  "skip",
+  "none"
+]);
+var FENCE_RE = /```(?:json)?\s*([\s\S]+?)```/i;
+function computeConversationSignals(messages, params) {
+  const windowSeconds = params.windowSeconds ?? CADENCE_WINDOW_SECONDS;
+  const own = normalizeHandle(params.ownHandle);
+  const prior = messages.filter(
+    (m) => isRecord(m) && m.id !== params.triggerMessageId
+  );
+  const firstContact = prior.length === 0;
+  const youHaveSpoken = prior.some((m) => messageIsOwn(m, own));
+  const timestamps = [];
+  for (const m of prior) {
+    const ts = parseTimestamp(m.created_at);
+    if (ts !== null) timestamps.push(ts);
+  }
+  const cutoff = params.nowMs - windowSeconds * 1e3;
+  const recentInWindow = timestamps.filter((ts) => ts >= cutoff).length;
+  let secondsSincePrevious = null;
+  if (timestamps.length > 0) {
+    const delta = (params.nowMs - Math.max(...timestamps)) / 1e3;
+    secondsSincePrevious = delta > 0 ? delta : 0;
+  }
+  return {
+    firstContact,
+    youHaveSpoken,
+    messagesLastWindow: recentInWindow + 1,
+    // +1 for the new message
+    secondsSincePrevious
+  };
+}
+function messageIsOwn(msg, ownHandleNorm) {
+  if (typeof msg.is_own === "boolean") return msg.is_own;
+  const sender = msg.sender ?? msg.from ?? msg.sender_handle ?? "";
+  return normalizeHandle(String(sender)) === ownHandleNorm;
+}
+function parseTimestamp(raw) {
+  if (typeof raw !== "string" || !raw) return null;
+  const t = Date.parse(raw);
+  return Number.isNaN(t) ? null : t;
+}
+function normalizeHandle(handle) {
+  return handle.replace(/^@/, "").toLowerCase();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function systemTemplate(handle) {
+  const h = `@${handle}`;
+  return `You are the reply gate for ${h}, an autonomous agent on AgentChat (a peer-to-peer messaging network for AI agents). A message just arrived. Your only job is to decide whether ${h} should reply to it now. You do NOT write the reply \u2014 you output one decision.
+
+"no_reply" is a SUCCESS, not a failure. Most healthy conversations are SUPPOSED to end; going quiet is the normal, correct outcome and is never rude here \u2014 on this network silence IS the acknowledgement.
+
+Judge DONE-NESS, not how interesting another message could be:
+
+Choose "reply" only if a further message accomplishes a concrete, still-OPEN purpose:
+- answer a substantive pending question or supply specifically requested information
+- make or respond to a decision, or unblock the peer on a real task
+- ${h} started this thread toward a goal and the peer's reply needs a substantive follow-up to reach it
+- new information genuinely requires ${h}'s input
+
+Choose "no_reply" when the exchange has reached its natural end \u2014 even if another clever or friendly message is easily possible:
+- it is trading pleasantries, mutual appreciation, agreement, or open-ended tangents / "riffing" with no open objective
+- a courtesy question that merely mirrors the exchange back ("and you?", "what are you working on?", "what tools are you using?") after the substantive part has run its course is part of the pleasantry, not an open task \u2014 it does not oblige a reply
+- the other side is acknowledging or closing out (thanks / ok / got it / sounds good / \u{1F44D} / bye) and replying would only prolong it
+- ${h} already answered what was asked and nothing new is on the table
+- in a group, the message is not addressed to ${h} and does not need it. (Groups only \u2014 in a direct conversation every message is addressed to ${h} by definition, so "not_addressed" never applies there.)
+
+"I could add something" is NOT a reason to reply. "Something concrete is unresolved and my reply resolves it" IS. Two agents keeping a chat alive by each politely asking the next question is the exact failure you exist to prevent \u2014 the thread being pleasant does not make it open. If the Pace line shows messages flying back and forth with each turn only restating, appreciating, or re-asking a mirrored question, that IS the loop \u2014 choose "no_reply". When unsure, prefer "no_reply".
+
+Respond with ONLY a JSON object \u2014 no prose, no markdown fences:
+{"decision": "reply" or "no_reply", "reason": "<one short sentence>", "category": "<one of: open_request, new_info, goal_followup, closing, acknowledgement, not_addressed, no_action_needed, spam, other>"}`;
+}
+function buildDecisionMessages(params) {
+  return [
+    { role: "system", content: systemTemplate(params.handle) },
+    {
+      role: "user",
+      content: buildUserContent({
+        handle: params.handle,
+        event: params.event,
+        history: params.history,
+        signals: params.signals ?? null,
+        maxHistory: params.maxHistory ?? MAX_HISTORY_TURNS
+      })
+    }
+  ];
+}
+function buildUserContent(params) {
+  const { handle, event, history, signals, maxHistory } = params;
+  const kind = event.conversationKind === "group" ? "group" : "direct";
+  const lines = [`Conversation type: ${kind}`];
+  if (signals) {
+    lines.push(`Relationship: ${relationshipPhrase(signals)}`);
+    if (signals.secondsSincePrevious !== null) {
+      lines.push(
+        `Pace: ${signals.messagesLastWindow} message(s) in the last ${CADENCE_WINDOW_SECONDS}s; ${formatGap(signals.secondsSincePrevious)} since the previous message`
+      );
+    }
+  }
+  lines.push(`Prior messages in this thread: ${history.length}`);
+  if (kind === "group") {
+    const mentioned = (event.contentText || "").toLowerCase().includes(`@${handle.toLowerCase()}`);
+    lines.push(
+      `Message directly addresses you: ${mentioned ? "yes" : "not explicitly"}`
+    );
+  }
+  lines.push("");
+  const rendered = renderHistory(history, maxHistory);
+  if (rendered.length > 0) {
+    lines.push("Recent conversation (oldest first):");
+    lines.push(...rendered);
+  } else {
+    lines.push("Recent conversation: (none \u2014 this is first contact)");
+  }
+  let newText = collapseWhitespace(event.contentText || "");
+  if (newText.length > 2e3) newText = `${newText.slice(0, 2e3)}\u2026`;
+  lines.push("");
+  lines.push(`New message from @${event.senderHandle}: ${newText}`);
+  lines.push("");
+  lines.push("Decide now: reply or no_reply?");
+  return lines.join("\n");
+}
+function renderHistory(history, maxHistory) {
+  const recent = history.length > maxHistory ? history.slice(history.length - maxHistory) : history;
+  const out = [];
+  for (const turn of recent) {
+    if (typeof turn.content !== "string" || !turn.content.trim()) continue;
+    const speaker = turn.role === "assistant" ? "you" : "peer";
+    let text = collapseWhitespace(turn.content);
+    if (text.length > 400) text = `${text.slice(0, 400)}\u2026`;
+    out.push(`${speaker}: ${text}`);
+  }
+  return out;
+}
+function relationshipPhrase(signals) {
+  if (signals.firstContact) return "first contact \u2014 no prior messages in this thread";
+  if (signals.youHaveSpoken) return "established \u2014 you have already replied in this thread";
+  return "this peer is messaging you, but you have not replied yet";
+}
+function formatGap(seconds) {
+  if (seconds < 90) return `${Math.round(seconds)}s`;
+  if (seconds < 5400) return `${Math.round(seconds / 60)}m`;
+  return `${Math.round(seconds / 3600)}h`;
+}
+function collapseWhitespace(text) {
+  return text.split(/\s+/).filter(Boolean).join(" ");
+}
+function parseDecision(text, opts = {}) {
+  const raw = extractJson(text);
+  if (raw === null) return null;
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(obj)) return null;
+  const decisionRaw = obj.decision;
+  if (typeof decisionRaw !== "string") return null;
+  const token = decisionRaw.trim().toLowerCase();
+  let reply;
+  if (REPLY_TOKENS.has(token)) reply = true;
+  else if (NO_REPLY_TOKENS.has(token)) reply = false;
+  else return null;
+  const reasonRaw = obj.reason;
+  let reason = typeof reasonRaw === "string" ? reasonRaw.trim() : "";
+  if (reason.length > 280) reason = reason.slice(0, 280);
+  const categoryRaw = obj.category;
+  let category = typeof categoryRaw === "string" ? categoryRaw.trim().toLowerCase() : "other";
+  if (!VALID_CATEGORIES.has(category)) category = "other";
+  return {
+    reply,
+    reason,
+    category,
+    source: opts.source ?? "llm",
+    latencyMs: opts.latencyMs ?? 0
+  };
+}
+function extractJson(text) {
+  if (!text || !text.trim()) return null;
+  let s = text.trim();
+  const fence = FENCE_RE.exec(s);
+  if (fence?.[1]) s = fence[1].trim();
+  const start = s.indexOf("{");
+  const end = s.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+  return s.slice(start, end + 1);
+}
+function gateFallback(failOpen, reason, latencyMs) {
+  return {
+    reply: failOpen,
+    reason,
+    category: "fallback",
+    source: failOpen ? "fail_open" : "fail_closed",
+    latencyMs
+  };
+}
+
+// src/binding/gate.ts
+var DEFAULT_GATE_TIMEOUT_MS = 2e4;
+var GATE_REASONING_LEVEL = "off";
+var GateTimeoutError = class extends Error {
+};
+function withTimeout(promise, ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return promise;
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new GateTimeoutError("gate decision timed out")), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      (err3) => {
+        clearTimeout(timer);
+        reject(err3);
+      }
+    );
+  });
+}
+async function decideReply(params) {
+  const signals = computeConversationSignals(params.rawMessages, {
+    ownHandle: params.ownHandle,
+    triggerMessageId: params.triggerMessageId,
+    nowMs: params.nowMs
+  });
+  const messages = buildDecisionMessages({
+    handle: params.handle,
+    event: params.event,
+    history: params.history,
+    signals
+  });
+  const systemPrompt = messages.find((m) => m.role === "system")?.content ?? "";
+  const userContent = messages.find((m) => m.role === "user")?.content ?? "";
+  const caller = params.caller ?? createSimpleCompletionGateCaller(params.cfg, params.agentId);
+  const maxTokens = params.maxTokens ?? DEFAULT_GATE_MAX_TOKENS;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_GATE_TIMEOUT_MS;
+  const start = Date.now();
+  let text;
+  try {
+    text = await withTimeout(caller({ systemPrompt, userContent, maxTokens }), timeoutMs);
+  } catch (err3) {
+    if (err3 instanceof GateTimeoutError) {
+      return gateFallback(params.failOpen, "decision_timeout", Date.now() - start);
+    }
+    const detail = err3 instanceof Error ? err3.message : String(err3);
+    return gateFallback(
+      params.failOpen,
+      `decision_call_error: ${detail}`.slice(0, 220),
+      Date.now() - start
+    );
+  }
+  const latencyMs = Date.now() - start;
+  const parsed = parseDecision(text, { source: "llm", latencyMs });
+  return parsed ?? gateFallback(params.failOpen, "unparseable_decision", latencyMs);
+}
+function createSimpleCompletionGateCaller(cfg, agentId) {
+  return async ({ systemPrompt, userContent, maxTokens, signal }) => {
+    const prepared = await simpleCompletionRuntime.prepareSimpleCompletionModelForAgent({
+      cfg,
+      // plugin-local OpenClawConfig alias → sdk's internal type
+      agentId,
+      allowMissingApiKeyModes: ["aws-sdk"],
+      // Do NOT skip discovery: it loads provider model catalogs. Skipping it
+      // works for providers with pure dynamic resolution (e.g. Fireworks) but
+      // makes catalog-based providers (Google/Gemini, Anthropic, OpenAI, …)
+      // fail with "Unknown model: <ref>" — the gate must resolve the agent's
+      // own model regardless of which provider it runs on.
+      skipAgentDiscovery: false
+    });
+    if ("error" in prepared) throw new Error(prepared.error);
+    const result = await simpleCompletionRuntime.completeWithPreparedSimpleCompletionModel({
+      model: prepared.model,
+      auth: prepared.auth,
+      cfg,
+      context: {
+        systemPrompt,
+        messages: [{ role: "user", content: userContent }]
+      },
+      // temperature 0 mirrors the Hermes gate: a binary policy decision must
+      // be as deterministic as the provider allows, not sampled creatively.
+      options: {
+        maxTokens,
+        temperature: 0,
+        reasoning: GATE_REASONING_LEVEL,
+        ...signal ? { signal } : {}
+      }
+    });
+    return result.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("");
+  };
+}
+
+// src/binding/inbound-bridge.ts
+var GATE_HISTORY_LIMIT = 30;
 function createInboundBridge(deps) {
   return async function onInbound(event) {
     switch (event.kind) {
@@ -2419,6 +2895,17 @@ async function handleMessage(deps, event) {
   if (!body && !event.content.attachmentId && !event.content.data) {
     return;
   }
+  const threadClosures = getThreadClosures(
+    deps.gatewayCfg,
+    deps.accountId
+  );
+  if (threadClosures.isClosed(event.conversationId)) {
+    deps.logger.info(
+      { conversationId: event.conversationId, messageId: event.messageId, sender: event.sender },
+      "inbound skipped for locally closed thread"
+    );
+    return;
+  }
   const channelRuntime = deps.channelRuntime;
   if (!channelRuntime || typeof channelRuntime.reply?.dispatchReplyWithBufferedBlockDispatcher !== "function") {
     deps.logger.error(
@@ -2433,6 +2920,7 @@ async function handleMessage(deps, event) {
     );
     return;
   }
+  const ts = typeof event.createdAt === "number" ? event.createdAt : Date.parse(event.createdAt);
   const recipientHandle = selfHandle ?? "me";
   const conversationLabel = event.conversationKind === "group" ? `group ${event.conversationId}` : `dm with @${senderHandle}`;
   const sendReply = async (replyText) => {
@@ -2445,36 +2933,107 @@ async function handleMessage(deps, event) {
       metadata: { reply_to: event.messageId }
     });
   };
+  const turnStartMs = Date.now();
   const deliver2 = async (payload) => {
-    const replyText = payload.text ?? extractText(payload.blocks);
-    await sendReply(replyText);
+    if (threadClosures.isClosed(event.conversationId)) {
+      deps.logger.info(
+        { conversationId: event.conversationId, messageId: event.messageId },
+        "reply suppressed for locally closed thread"
+      );
+      return;
+    }
+    if (hasAgentSendSince(deps.accountId, event.conversationId, turnStartMs)) {
+      deps.logger.info(
+        { conversationId: event.conversationId, messageId: event.messageId },
+        "final turn text suppressed \u2014 agent already sent its reply via a message tool this turn"
+      );
+      return;
+    }
+    await sendReply(payload.text ?? extractText(payload.blocks));
   };
   try {
-    if (event.conversationKind === "direct") {
-      await directDm.dispatchInboundDirectDmWithRuntime({
-        cfg: deps.gatewayCfg,
-        runtime: { channel: channelRuntime },
-        channel: "agentchat",
-        channelLabel: "AgentChat",
-        accountId: deps.accountId,
-        peer: { kind: "direct", id: senderHandle },
-        senderId: senderHandle,
-        senderAddress: `@${senderHandle}`,
-        recipientAddress: `@${recipientHandle}`,
-        conversationLabel,
-        rawBody: body,
-        messageId: event.messageId,
-        timestamp: typeof event.createdAt === "number" ? event.createdAt : Date.parse(event.createdAt),
-        provider: "agentchat",
-        surface: "agentchat",
-        deliver: deliver2,
-        onRecordError: (err3) => {
-          deps.logger.error(
-            { err: err3 instanceof Error ? err3.message : String(err3), messageId: event.messageId },
-            "recordInboundSession failed"
-          );
+    const runtime = channelRuntime;
+    const peer = event.conversationKind === "group" ? { kind: "group", id: event.conversationId } : { kind: "direct", id: senderHandle };
+    const { route, buildEnvelope } = inboundEnvelope.resolveInboundRouteEnvelopeBuilderWithRuntime({
+      cfg: deps.gatewayCfg,
+      channel: "agentchat",
+      accountId: deps.accountId,
+      peer,
+      runtime
+    });
+    if (gateEnabled()) {
+      const decision = await runReplyGate({
+        deps,
+        event,
+        body,
+        agentId: route.agentId,
+        selfHandle,
+        senderHandle,
+        nowMs: Number.isFinite(ts) ? ts : Date.now()
+      });
+      deps.logger.info(
+        {
+          conversationId: event.conversationId,
+          messageId: event.messageId,
+          reply: decision.reply,
+          source: decision.source,
+          category: decision.category,
+          latencyMs: decision.latencyMs,
+          reason: decision.reason
         },
-        onDispatchError: (err3, info) => {
+        "reply gate decision"
+      );
+      if (!decision.reply) return;
+    }
+    const { storePath, body: envelopeBody } = buildEnvelope({
+      channel: "AgentChat",
+      from: conversationLabel,
+      body,
+      timestamp: ts
+    });
+    const finalize = channelRuntime.reply.finalizeInboundContext;
+    const ctxPayload = finalize({
+      Body: envelopeBody,
+      BodyForAgent: body,
+      RawBody: body,
+      CommandBody: body,
+      From: `@${senderHandle}`,
+      To: `@${recipientHandle}`,
+      SessionKey: route.sessionKey,
+      AccountId: deps.accountId,
+      ChatType: event.conversationKind === "group" ? "group" : "direct",
+      ConversationLabel: conversationLabel,
+      SenderId: senderHandle,
+      Provider: "agentchat",
+      Surface: "agentchat",
+      MessageSid: event.messageId,
+      MessageSidFull: event.messageId,
+      Timestamp: ts,
+      OriginatingChannel: "agentchat",
+      OriginatingTo: `@${recipientHandle}`
+    });
+    const session = channelRuntime.session;
+    await inboundReplyDispatch.dispatchChannelInboundReply({
+      cfg: deps.gatewayCfg,
+      channel: "agentchat",
+      accountId: deps.accountId,
+      agentId: route.agentId,
+      routeSessionKey: route.sessionKey,
+      storePath,
+      ctxPayload,
+      recordInboundSession: session.recordInboundSession,
+      dispatchReplyWithBufferedBlockDispatcher: channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher,
+      // Under `automatic` (the default) the framework hands the agent's final
+      // turn text to this `deliver`, which sends it to the source. Under the
+      // opt-in `message_tool_only` mode the turn text is suppressed and the
+      // agent sends via the message tool instead, so `deliver` only fires on a
+      // framework fallback. Either way a gated `no_reply` turn never runs, so
+      // nothing is sent.
+      delivery: {
+        deliver: async (payload) => {
+          await deliver2(payload);
+        },
+        onError: (err3, info) => {
           deps.logger.error(
             {
               err: err3 instanceof Error ? err3.message : String(err3),
@@ -2484,84 +3043,103 @@ async function handleMessage(deps, event) {
             "inbound dispatch failed"
           );
         }
-      });
-    } else {
-      const ts = typeof event.createdAt === "number" ? event.createdAt : Date.parse(event.createdAt);
-      const runtime = channelRuntime;
-      const { route, buildEnvelope } = inboundEnvelope.resolveInboundRouteEnvelopeBuilderWithRuntime({
-        cfg: deps.gatewayCfg,
-        channel: "agentchat",
-        accountId: deps.accountId,
-        peer: { kind: "group", id: event.conversationId },
-        runtime
-      });
-      const { storePath, body: envelopeBody } = buildEnvelope({
-        channel: "AgentChat",
-        from: conversationLabel,
-        body,
-        timestamp: ts
-      });
-      const finalize = channelRuntime.reply.finalizeInboundContext;
-      const ctxPayload = finalize({
-        Body: envelopeBody,
-        BodyForAgent: body,
-        RawBody: body,
-        CommandBody: body,
-        From: `@${senderHandle}`,
-        To: `@${recipientHandle}`,
-        SessionKey: route.sessionKey,
-        AccountId: deps.accountId,
-        ChatType: "group",
-        ConversationLabel: conversationLabel,
-        SenderId: senderHandle,
-        Provider: "agentchat",
-        Surface: "agentchat",
-        MessageSid: event.messageId,
-        MessageSidFull: event.messageId,
-        Timestamp: ts,
-        OriginatingChannel: "agentchat",
-        OriginatingTo: `@${recipientHandle}`
-      });
-      const session = channelRuntime.session;
-      await inboundReplyDispatch.recordInboundSessionAndDispatchReply({
-        cfg: deps.gatewayCfg,
-        channel: "agentchat",
-        accountId: deps.accountId,
-        agentId: route.agentId,
-        routeSessionKey: route.sessionKey,
-        storePath,
-        ctxPayload,
-        recordInboundSession: session.recordInboundSession,
-        dispatchReplyWithBufferedBlockDispatcher: channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher,
-        deliver: deliver2,
+      },
+      replyOptions: { sourceReplyDeliveryMode: resolveSourceReplyMode() },
+      record: {
         onRecordError: (err3) => {
           deps.logger.error(
             { err: err3 instanceof Error ? err3.message : String(err3), messageId: event.messageId },
-            "recordInboundSession failed (group)"
-          );
-        },
-        onDispatchError: (err3, info) => {
-          deps.logger.error(
-            {
-              err: err3 instanceof Error ? err3.message : String(err3),
-              messageId: event.messageId,
-              kind: info.kind
-            },
-            "inbound dispatch failed (group)"
+            "recordInboundSession failed"
           );
         }
-      });
-    }
+      }
+    });
   } catch (err3) {
     deps.logger.error(
-      {
-        err: err3 instanceof Error ? err3.message : String(err3),
-        messageId: event.messageId
-      },
+      { err: err3 instanceof Error ? err3.message : String(err3), messageId: event.messageId },
       "inbound dispatch failed"
     );
   }
 }
+async function runReplyGate(params) {
+  const { deps, event, body, agentId, selfHandle, senderHandle, nowMs } = params;
+  const ownHandle = selfHandle ?? "";
+  let rawMessages = [];
+  try {
+    const client = getClient({ accountId: deps.accountId, config: deps.config });
+    const fetched = await client.getMessages(event.conversationId, { limit: GATE_HISTORY_LIMIT });
+    if (Array.isArray(fetched)) rawMessages = fetched;
+  } catch (err3) {
+    deps.logger.warn(
+      { err: err3 instanceof Error ? err3.message : String(err3), conversationId: event.conversationId },
+      "reply gate: history fetch failed \u2014 deciding on the new message alone"
+    );
+  }
+  const gateEvent = {
+    conversationKind: event.conversationKind,
+    senderHandle,
+    contentText: body
+  };
+  return decideReply({
+    cfg: deps.gatewayCfg,
+    agentId,
+    handle: ownHandle.replace(/^@/, ""),
+    event: gateEvent,
+    history: translateHistory(rawMessages, ownHandle, event.conversationKind, event.messageId),
+    rawMessages,
+    triggerMessageId: event.messageId,
+    ownHandle,
+    nowMs,
+    failOpen: gateFailOpen(),
+    timeoutMs: gateTimeoutMs(),
+    caller: deps.gateCaller
+  });
+}
+function translateHistory(messages, ownHandle, conversationKind, triggerMessageId) {
+  const own = ownHandle.replace(/^@/, "").toLowerCase();
+  const isGroup = conversationKind === "group";
+  const sorted = [...messages].filter((m) => Boolean(m) && typeof m === "object").sort((a, b) => readSeq(a) - readSeq(b));
+  const out = [];
+  for (const m of sorted) {
+    if (m.id === triggerMessageId) continue;
+    const type = typeof m.type === "string" ? m.type : "text";
+    if (type !== "text") continue;
+    const content = m.content;
+    const text = content && typeof content === "object" ? content.text : void 0;
+    if (typeof text !== "string" || !text) continue;
+    const senderRaw = String(m.sender ?? m.from ?? m.sender_handle ?? "");
+    const isOwn = typeof m.is_own === "boolean" ? m.is_own : senderRaw.replace(/^@/, "").toLowerCase() === own;
+    if (isOwn) {
+      out.push({ role: "assistant", content: text });
+    } else if (isGroup) {
+      out.push({ role: "user", content: `[@${senderRaw.replace(/^@/, "") || "?"}] ${text}` });
+    } else {
+      out.push({ role: "user", content: text });
+    }
+  }
+  return out;
+}
+function readSeq(m) {
+  const seq = m.seq;
+  return typeof seq === "number" ? seq : 0;
+}
+var OFF_TOKENS = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+var ON_TOKENS = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
+function gateEnabled() {
+  return !OFF_TOKENS.has((process.env.AGENTCHAT_REPLY_GATE_ENABLED ?? "").trim().toLowerCase());
+}
+function gateFailOpen() {
+  return ON_TOKENS.has((process.env.AGENTCHAT_REPLY_GATE_FAIL_OPEN ?? "").trim().toLowerCase());
+}
+function gateTimeoutMs() {
+  const raw = process.env.AGENTCHAT_REPLY_GATE_TIMEOUT_MS;
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function resolveSourceReplyMode() {
+  return (process.env.AGENTCHAT_SOURCE_REPLY_MODE ?? "").trim().toLowerCase() === "message_tool_only" ? "message_tool_only" : "automatic";
+}
 function handleGroupInvite(deps, event) {
   deps.logger.info(
     {
@@ -2709,27 +3287,6 @@ var agentchatGatewayAdapter = {
     });
   }
 };
-var cache = /* @__PURE__ */ new Map();
-function getClient({ accountId, config, options }) {
-  const existing = cache.get(accountId);
-  if (existing && existing.apiKey === config.apiKey && existing.apiBase === config.apiBase) {
-    return existing.client;
-  }
-  const client = new agentchatme.AgentChatClient({
-    apiKey: config.apiKey,
-    baseUrl: config.apiBase,
-    ...options
-  });
-  cache.set(accountId, {
-    client,
-    apiKey: config.apiKey,
-    apiBase: config.apiBase
-  });
-  return client;
-}
-function disposeClient(accountId) {
-  cache.delete(accountId);
-}
 
 // src/binding/outbound.ts
 function resolveConfig(cfg, accountId) {
@@ -2791,6 +3348,7 @@ async function deliver(ctx, attachmentId) {
     attachmentId
   );
   const result = await runtime.sendMessage(input);
+  recordAgentSend(accountId, result.message.conversation_id);
   return {
     channel: AGENTCHAT_CHANNEL_ID,
     messageId: result.message.id,
@@ -2860,8 +3418,8 @@ async function uploadMediaFromUrl(ctx, mediaUrl) {
   let contentType;
   let filename = "attachment";
   if (mediaUrl.startsWith("file://") && ctx.mediaReadFile) {
-    const path = decodeURIComponent(mediaUrl.replace(/^file:\/\//, ""));
-    const buf = await ctx.mediaReadFile(path);
+    const path3 = decodeURIComponent(mediaUrl.replace(/^file:\/\//, ""));
+    const buf = await ctx.mediaReadFile(path3);
     if (buf.byteLength > MAX_MEDIA_BYTES) {
       throw new AgentChatChannelError(
         "terminal-user",
@@ -2871,7 +3429,7 @@ async function uploadMediaFromUrl(ctx, mediaUrl) {
     const copy = new Uint8Array(buf.byteLength);
     copy.set(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
     bytes = copy.buffer;
-    filename = path.split(/[\\/]/).pop() ?? filename;
+    filename = path3.split(/[\\/]/).pop() ?? filename;
   } else {
     assertMediaUrlSafe(mediaUrl);
     const controller = new AbortController();
@@ -3026,8 +3584,8 @@ function err(message) {
     details: { error: message }
   };
 }
-function str(params, key) {
-  const v = params[key];
+function str(params, key2) {
+  const v = params[key2];
   return typeof v === "string" ? v : void 0;
 }
 function resolveConfig2(ctx) {
@@ -3284,6 +3842,7 @@ var agentchatAgentToolsFactory = ({ cfg }) => {
             content: { text: p.message },
             ...p.replyToMessageId ? { metadata: { reply_to: p.replyToMessageId } } : {}
           });
+          recordAgentSend(r.accountId, result.message.conversation_id);
           const summaryParts = [
             `sent to @${handle} \u2014 message ${result.message.id} in ${result.message.conversation_id}`
           ];
@@ -3806,6 +4365,88 @@ ${lines.join("\n")}`);
         }
       }
     }),
+    tool({
+      name: "agentchat_close_local_thread",
+      description: "Locally close a conversation thread for this OpenClaw AgentChat account. Future inbound on this exact conversation id will not enter the reply pipeline here, but this does not block the peer and either side can still start a brand-new thread later.",
+      parameters: typebox.Type.Object({
+        conversationId: typebox.Type.String(),
+        reason: typebox.Type.Optional(typebox.Type.String({ maxLength: 200 })),
+        account: ACCOUNT_PARAM
+      }),
+      execute: async (_id, p) => {
+        const r = clientFor(cfg, p.account);
+        if ("error" in r) return err2(r.error);
+        const closures = getThreadClosures(cfg, r.accountId);
+        const record = closures.close(p.conversationId, p.reason);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `closed ${record.conversationId} locally`
+            }
+          ],
+          details: {
+            conversationId: record.conversationId,
+            closedAt: record.closedAt,
+            reason: record.reason,
+            localOnly: true
+          }
+        };
+      }
+    }),
+    tool({
+      name: "agentchat_reopen_local_thread",
+      description: "Re-open a previously locally closed conversation thread so new inbound on that conversation id can reach the reply pipeline again.",
+      parameters: typebox.Type.Object({
+        conversationId: typebox.Type.String(),
+        account: ACCOUNT_PARAM
+      }),
+      execute: async (_id, p) => {
+        const r = clientFor(cfg, p.account);
+        if ("error" in r) return err2(r.error);
+        const closures = getThreadClosures(cfg, r.accountId);
+        const reopened = closures.reopen(p.conversationId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: reopened ? `re-opened ${p.conversationId} locally` : `${p.conversationId} was not locally closed`
+            }
+          ],
+          details: {
+            conversationId: p.conversationId,
+            reopened,
+            localOnly: true
+          }
+        };
+      }
+    }),
+    tool({
+      name: "agentchat_list_local_closed_threads",
+      description: "List conversation threads currently closed locally for this OpenClaw AgentChat account. These are client-side only, not server-side blocks or mutes.",
+      parameters: typebox.Type.Object({
+        account: ACCOUNT_PARAM
+      }),
+      execute: async (_id, p) => {
+        const r = clientFor(cfg, p.account);
+        if ("error" in r) return err2(r.error);
+        const closures = getThreadClosures(cfg, r.accountId);
+        const closed = closures.list();
+        if (closed.length === 0) {
+          return {
+            content: [{ type: "text", text: "no locally closed threads" }],
+            details: { closedThreads: [], localOnly: true }
+          };
+        }
+        const lines = closed.map(
+          (record) => `${record.conversationId} \u2014 ${record.closedAt}${record.reason ? ` \u2014 ${record.reason}` : ""}`
+        );
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          details: { closedThreads: closed, localOnly: true }
+        };
+      }
+    }),
     tool({
       name: "agentchat_get_conversation_history",
       description: "Fetch recent messages from a specific conversation. Use this to: catch up on a thread you've been away from, load context before replying to an old message, or read back what you and a contact discussed last time. Returns messages oldest-first so the tail of your output is the most recent. Pass `beforeSeq` to paginate further back.",
@@ -4104,6 +4745,7 @@ ${lines.join("\n")}`);
             to: "chatfather",
             content: { text: p.message }
           });
+          recordAgentSend(r.accountId, result.message.conversation_id);
           return ok2(
             `message sent to @chatfather (id: ${result.message.id}). Watch your inbox for the reply.`
           );