@clwnt/clawnet 0.7.7 → 0.7.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clwnt/clawnet",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "type": "module",
   "description": "ClawNet integration for OpenClaw — poll inbox, route messages to hooks",
   "files": [

package/src/cli.ts

@@ -154,6 +154,10 @@ export function buildStatusText(api: any): string {
       lines.push("Polling: **PAUSED** (run /clawnet resume to restart)");
     }
     lines.push(`Poll interval: ${pluginCfg.pollEverySeconds ?? "?"}s`);
+    const notifyOn = pluginCfg.notifyOnNew ?? true;
+    const remindH = pluginCfg.remindAfterHours ?? null;
+    lines.push(`Notify on new: ${notifyOn ? "on" : "off"}`);
+    lines.push(`Reminder interval: ${remindH ? `${remindH}h` : "never"}`);
 
     const accounts: any[] = pluginCfg.accounts ?? [];
     const agentList: any[] = currentConfig?.agents?.list ?? [];

package/src/config.ts

@@ -19,6 +19,8 @@ export interface ClawnetConfig {
   maxSnippetChars: number;
   setupVersion: number;
   paused: boolean;
+  notifyOnNew: boolean;
+  remindAfterHours: number | null;
 }
 
 const DEFAULTS: ClawnetConfig = {
@@ -32,6 +34,8 @@ const DEFAULTS: ClawnetConfig = {
   maxSnippetChars: 500,
   setupVersion: 0,
   paused: false,
+  notifyOnNew: true,
+  remindAfterHours: 4,
 };
 
 export function parseConfig(raw: Record<string, unknown>): ClawnetConfig {
@@ -67,6 +71,8 @@ export function parseConfig(raw: Record<string, unknown>): ClawnetConfig {
     deliveryMethod:
       raw.deliveryMethod === "agent" ? "agent" : DEFAULTS.deliveryMethod,
     paused: raw.paused === true,
+    notifyOnNew: raw.notifyOnNew !== false,
+    remindAfterHours: typeof raw.remindAfterHours === "number" ? raw.remindAfterHours : null,
   };
 }
 

package/src/service.ts

@@ -11,6 +11,7 @@ interface InboxMessage {
   content: string;
   subject?: string;
   created_at: string;
+  type: "email" | "task";
 }
 
 export interface ServiceState {
@@ -72,7 +73,7 @@ async function reloadOnboardingMessage(): Promise<void> {
 
 const SKILL_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 const SKILL_FILES = ["skill.json", "api-reference.md", "inbox-handler.md", "capabilities.json", "hook-template.txt", "tool-descriptions.json", "onboarding-message.txt", "inbox-protocol.md"];
-export const PLUGIN_VERSION = "0.7.7"; // Reported to server via PATCH /me every 6h
+export const PLUGIN_VERSION = "0.7.8"; // Reported to server via PATCH /me every 6h
 
 function loadFreshConfig(api: any): ClawnetConfig {
   const raw = api.runtime?.config?.loadConfig?.()?.plugins?.entries?.clawnet?.config ?? {};
@@ -134,6 +135,9 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
 
   // --- Batch delivery ---
 
+  // Per-account auth context for mark-notified calls from deliverBatch
+  const accountAuth = new Map<string, { token: string; baseUrl: string }>();
+
   async function deliverBatch(accountId: string, agentId: string, messages: InboxMessage[]) {
     if (messages.length === 0) return;
 
@@ -163,6 +167,37 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       api.logger.info(
         `[clawnet] ${accountId}: delivered ${messages.length} message(s) to ${agentId} via ${freshCfg.deliveryMethod}`,
       );
+
+      // Post-delivery: mark items as notified + mark A2A tasks as working
+      const auth = accountAuth.get(accountId);
+      if (auth) {
+        const emailIds = messages.filter((m) => m.type === "email").map((m) => m.id);
+        const taskIds = messages.filter((m) => m.type === "task").map((m) => m.id);
+
+        // Mark notified (non-fatal)
+        if (emailIds.length > 0 || taskIds.length > 0) {
+          try {
+            const markRes = await fetch(`${auth.baseUrl}/inbox/mark-notified`, {
+              method: "POST",
+              headers: { Authorization: `Bearer ${auth.token}`, "Content-Type": "application/json" },
+              body: JSON.stringify({
+                ...(emailIds.length > 0 ? { message_ids: emailIds } : {}),
+                ...(taskIds.length > 0 ? { task_ids: taskIds } : {}),
+              }),
+            });
+            if (markRes.ok) {
+              const markData = await markRes.json().catch(() => ({})) as Record<string, unknown>;
+              api.logger.info(`[clawnet] ${accountId}: marked notified (${markData.marked_messages ?? 0} msgs, ${markData.marked_tasks ?? 0} tasks)`);
+            } else {
+              const errText = await markRes.text().catch(() => "");
+              api.logger.warn(`[clawnet] ${accountId}: mark-notified returned ${markRes.status}: ${errText}`);
+            }
+          } catch (err: any) {
+            api.logger.warn(`[clawnet] ${accountId}: mark-notified failed (non-fatal): ${err.message}`);
+          }
+        }
+
+      }
     } catch (err: any) {
       state.lastError = { message: err.message, at: new Date() };
       state.counters.errors++;
@@ -286,13 +321,16 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
 
   // --- Poll ---
 
-  async function pollAccount(account: ClawnetAccount): Promise<number> {
+  async function pollAccount(account: ClawnetAccount): Promise<{ a2aDmCount: number; sentTaskUpdates: number; notifyCount: number }> {
     const resolvedToken = resolveToken(account.token);
     if (!resolvedToken) {
       api.logger.warn(`[clawnet] No token resolved for account "${account.id}", skipping`);
-      return 0;
+      return { a2aDmCount: 0, sentTaskUpdates: 0, notifyCount: 0 };
     }
 
+    // Store auth context for deliverBatch to use for mark-notified calls
+    accountAuth.set(account.id, { token: resolvedToken, baseUrl: cfg.baseUrl });
+
     const headers = {
       Authorization: `Bearer ${resolvedToken}`,
       "Content-Type": "application/json",
@@ -307,11 +345,14 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       count: number;
       task_count?: number;
       sent_task_updates?: number;
+      notify_count?: number;
       plugin_config?: {
         poll_seconds: number;
         debounce_seconds: number;
         max_batch_size: number;
         deliver_channel: string;
+        notify_on_new?: boolean;
+        remind_after_hours?: number | null;
       };
     };
 
@@ -335,30 +376,44 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
         cfg.deliver.channel = pc.deliver_channel;
         changed = true;
       }
+      if (pc.notify_on_new !== undefined && pc.notify_on_new !== cfg.notifyOnNew) {
+        cfg.notifyOnNew = pc.notify_on_new;
+        changed = true;
+      }
+      if (pc.remind_after_hours !== undefined && pc.remind_after_hours !== cfg.remindAfterHours) {
+        cfg.remindAfterHours = pc.remind_after_hours;
+        changed = true;
+      }
       if (changed) {
-        api.logger.info(`[clawnet] Config updated from server: poll=${cfg.pollEverySeconds}s debounce=${cfg.debounceSeconds}s batch=${cfg.maxBatchSize}`);
+        api.logger.info(`[clawnet] Config updated from server: poll=${cfg.pollEverySeconds}s debounce=${cfg.debounceSeconds}s batch=${cfg.maxBatchSize} notify=${cfg.notifyOnNew} remind=${cfg.remindAfterHours ?? "never"}`);
       }
     }
 
     const a2aDmCount = checkData.task_count ?? 0;
     const sentTaskUpdates = checkData.sent_task_updates ?? 0;
+    const notifyCount = checkData.notify_count ?? (checkData.count + a2aDmCount + sentTaskUpdates);
 
     if (checkData.count === 0) {
       // Email inbox clear — release any delivery lock (agent finished processing)
       deliveryLock.delete(account.id);
-      return { a2aDmCount, sentTaskUpdates };
+      return { a2aDmCount, sentTaskUpdates, notifyCount };
+    }
+
+    // If nothing needs notification, skip fetch (but don't release lock — inbox still has items)
+    if (notifyCount === 0) {
+      return { a2aDmCount, sentTaskUpdates, notifyCount };
     }
 
-    // Skip if a recent webhook delivery is still being processed by the LLM.
+    // Skip if a recent delivery is still being processed.
     // TTL-based lock: after successful POST, lock for 10 min to let the agent work.
     const lockUntil = deliveryLock.get(account.id);
     if (lockUntil && new Date() < lockUntil) {
       api.logger.debug?.(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting (delivery lock active, skipping)`);
-      return { a2aDmCount, sentTaskUpdates };
+      return { a2aDmCount, sentTaskUpdates, notifyCount };
     }
 
     state.lastInboxNonEmptyAt = new Date();
-    api.logger.info(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting`);
+    api.logger.info(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting (${notifyCount} to notify)`);
 
     // Fetch full messages
     const inboxRes = await fetch(`${cfg.baseUrl}/inbox`, { headers });
@@ -367,7 +422,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     }
     const inboxData = (await inboxRes.json()) as { messages: Array<Record<string, any>> };
 
-    if (inboxData.messages.length === 0) return { a2aDmCount, sentTaskUpdates };
+    if (inboxData.messages.length === 0) return { a2aDmCount, sentTaskUpdates, notifyCount };
 
     // Normalize API field names: API returns "from", plugin uses "from_agent"
     const normalized: InboxMessage[] = inboxData.messages.map((m) => ({
@@ -376,6 +431,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       content: m.content,
       subject: m.email?.subject ?? m.subject,
       created_at: m.created_at,
+      type: "email" as const,
     }));
 
     state.counters.messagesSeen += normalized.length;
@@ -385,7 +441,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     pendingMessages.set(account.id, [...existing, ...normalized]);
     scheduleFlush(account.id, account.agentId);
 
-    return { a2aDmCount, sentTaskUpdates };
+    return { a2aDmCount, sentTaskUpdates, notifyCount };
   }
 
   async function pollAccountA2A(account: ClawnetAccount, a2aDmCount: number) {
@@ -427,7 +483,8 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
 
     api.logger.info(`[clawnet] ${account.id}: ${tasks.length} A2A task(s) to deliver`);
 
-    // Convert A2A tasks to the message format the hook expects
+    // Convert A2A tasks to the message format for delivery
+    // mark-notified happens post-delivery in deliverBatch
     const messages: InboxMessage[] = tasks.map((task) => {
       const history = task.history as Array<{ role: string; parts: Array<{ text?: string }> }> ?? [];
       const lastMsg = history[history.length - 1];
@@ -438,6 +495,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
         from_agent: task.from,
         content: `[A2A Task ${task.id}]${contactInfo}\n${text}`,
         created_at: (task.status as any)?.timestamp ?? new Date().toISOString(),
+        type: "task" as const,
       };
     });
 
@@ -445,28 +503,6 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     const existing = pendingMessages.get(account.id) ?? [];
     pendingMessages.set(account.id, [...existing, ...messages]);
     scheduleFlush(account.id, account.agentId);
-
-    // Mark delivered tasks as 'working' so they don't get re-delivered on next poll.
-    // This is the equivalent of marking emails 'read' — acknowledges receipt.
-    for (const task of tasks) {
-      try {
-        await fetch(`${cfg.baseUrl}/a2a`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${resolvedToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            jsonrpc: "2.0",
-            id: `ack-${task.id}`,
-            method: "tasks/respond",
-            params: { id: task.id, state: "working" },
-          }),
-        });
-      } catch {
-        // Non-fatal — task may get re-delivered next cycle
-      }
-    }
   }
 
   async function pollSentTaskUpdates(account: ClawnetAccount) {
@@ -477,12 +513,12 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     const lockUntil = deliveryLock.get(account.id);
     if (lockUntil && new Date() < lockUntil) return;
 
-    // Fetch tasks I sent that need attention
+    // Fetch tasks I sent that need my attention or have finished
     const body = {
       jsonrpc: "2.0",
       id: `sent-poll-${Date.now()}`,
       method: "tasks/list",
-      params: { role: "sender", status: "input-required", limit: 50 },
+      params: { role: "sender", status: "input-required,completed,failed", limit: 50 },
     };
     const res = await fetch(`${cfg.baseUrl}/a2a`, {
       method: "POST",
@@ -512,6 +548,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
         from_agent: task.to, // the agent that responded
         content: `[Task update: ${taskState}] Re: "${text.slice(0, 100)}${text.length > 100 ? "…" : ""}"`,
         created_at: (task.status as any)?.timestamp ?? new Date().toISOString(),
+        type: "task" as const,
       };
     });
 
@@ -565,10 +602,10 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     let hadError = false;
     for (const account of enabledAccounts) {
       try {
-        const { a2aDmCount, sentTaskUpdates } = await pollAccount(account);
+        const { a2aDmCount, sentTaskUpdates, notifyCount } = await pollAccount(account);
 
         // Also poll for A2A DMs if any pending
-        if (a2aDmCount > 0) {
+        if (a2aDmCount > 0 && notifyCount > 0) {
           try {
             await pollAccountA2A(account, a2aDmCount);
           } catch (a2aErr: any) {
@@ -577,7 +614,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
         }
 
         // Poll for sent task updates (tasks I sent that got a response)
-        if (sentTaskUpdates > 0) {
+        if (sentTaskUpdates > 0 && notifyCount > 0) {
           try {
             await pollSentTaskUpdates(account);
           } catch (err: any) {

package/src/tools.ts

@@ -155,6 +155,8 @@ interface CapabilityOp {
   description: string;
   params?: Record<string, { type: string; description: string; required?: boolean }>;
   rawBodyParam?: string; // If set, send this param as raw text body instead of JSON
+  jsonrpc?: boolean;     // If true, dispatch via a2aCall() instead of REST
+  rpc_method?: string;   // JSON-RPC method name (required when jsonrpc is true)
 }
 
 const BUILTIN_OPERATIONS: CapabilityOp[] = [
@@ -201,6 +203,12 @@ const BUILTIN_OPERATIONS: CapabilityOp[] = [
   { operation: "profile.capabilities", method: "PATCH", path: "/me/capabilities", description: "Set agent capabilities list", params: {
     capabilities: { type: "array", description: "List of capability strings (replaces all)", required: true },
   }},
+  // Notification settings
+  { operation: "notifications.get", method: "GET", path: "/me/notifications", description: "Get notification preferences (notify_on_new, remind_after_hours)" },
+  { operation: "notifications.update", method: "PATCH", path: "/me/notifications", description: "Update notification preferences", params: {
+    notify_on_new: { type: "boolean", description: "Notify when new messages/tasks arrive (default: true)" },
+    remind_after_hours: { type: "number", description: "Re-notify about unresolved items every N hours (1-168), or null to disable reminders" },
+  }},
   // Contacts
   { operation: "contacts.list", method: "GET", path: "/contacts", description: "List your contacts", params: {
     type: { type: "string", description: "'email' or 'agent'" },
@@ -268,6 +276,30 @@ const BUILTIN_OPERATIONS: CapabilityOp[] = [
   { operation: "account.rate_limits", method: "GET", path: "/me/rate-limits", description: "Check your current rate limits" },
   // Docs
   { operation: "docs.help", method: "GET", path: "/docs/skill", description: "Get the full ClawNet documentation — features, usage examples, safety rules, setup, troubleshooting, and rate limits" },
+  // A2A (JSON-RPC via /a2a)
+  { operation: "a2a.card.update", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "card/update", description: "Update your A2A Agent Card skills", params: {
+    skills: { type: "array", description: "Array of {id, name, description} skill objects", required: true },
+  }},
+  { operation: "a2a.tasks.list", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/list", description: "List your A2A tasks", params: {
+    status: { type: "string", description: "Filter by status (e.g. 'submitted', 'working', 'completed', 'failed', comma-separated for multiple)" },
+    role: { type: "string", description: "'sender' or 'recipient'" },
+    limit: { type: "number", description: "Max tasks to return" },
+  }},
+  { operation: "a2a.tasks.get", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/get", description: "Get a specific A2A task by ID", params: {
+    id: { type: "string", description: "Task ID", required: true },
+  }},
+  { operation: "a2a.tasks.respond", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/respond", description: "Respond to an A2A task", params: {
+    id: { type: "string", description: "Task ID", required: true },
+    state: { type: "string", description: "New state: completed, input-required, working, or failed", required: true },
+    message: { type: "string", description: "Response message text" },
+    artifacts: { type: "array", description: "Array of artifact objects (for completed tasks)" },
+  }},
+  { operation: "a2a.tasks.cancel", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/cancel", description: "Cancel an A2A task", params: {
+    id: { type: "string", description: "Task ID", required: true },
+  }},
+  { operation: "a2a.tasks.count", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/count", description: "Count A2A tasks by status", params: {
+    status: { type: "string", description: "Filter by status" },
+  }},
 ];
 
 // --- Dynamic capabilities ---
@@ -537,11 +569,11 @@ export function registerTools(api: any) {
 
   api.registerTool((ctx: { agentId?: string; sessionKey?: string }) => ({
     name: "clawnet_task_send",
-    description: toolDesc("clawnet_task_send", "Send a task to another ClawNet agent. Use this when you need something from another agent — a question answered, an action performed, information looked up. Returns a task ID to check for their response later. For fire-and-forget notifications, use email instead."),
+    description: toolDesc("clawnet_task_send", "Send a task to another agent. Works with ClawNet agent names (e.g. 'Tom') or external A2A endpoint URLs (e.g. 'https://example.com/a2a/agent'). Use this when you need something from another agent — a question answered, an action performed, information looked up. Returns a task ID to check for their response later. For fire-and-forget notifications, use email instead."),
     parameters: {
       type: "object",
       properties: {
-        to: { type: "string", description: "Recipient agent name" },
+        to: { type: "string", description: "Recipient: agent name (e.g. 'Tom') or external A2A URL (e.g. 'https://example.com/a2a/agent')" },
         message: { type: "string", description: "Message content" },
         task_id: { type: "string", description: "If following up on a task (after agent asked for input), provide the task ID" },
       },
@@ -549,6 +581,26 @@ export function registerTools(api: any) {
     },
     async execute(_id: string, params: { to: string; message: string; task_id?: string }) {
       const cfg = loadFreshConfig(api);
+      const isExternalUrl = params.to.startsWith("https://") || params.to.startsWith("http://");
+
+      if (params.to.startsWith("http://")) {
+        return textResult({ error: "Only HTTPS URLs are supported for external A2A endpoints. Use https:// instead of http://." });
+      }
+
+      if (isExternalUrl) {
+        // External A2A: route through tasks/send-external on internal endpoint
+        const a2aParams: Record<string, unknown> = {
+          url: params.to,
+          message: { role: "user", parts: [{ kind: "text", text: params.message }] },
+        };
+        if (params.task_id) {
+          a2aParams.taskId = params.task_id;
+        }
+        const result = await a2aCall(cfg, "/a2a", "tasks/send-external", a2aParams, ctx?.agentId, ctx?.sessionKey);
+        return textResult(result.data);
+      }
+
+      // Internal ClawNet agent: existing path
       const a2aParams: Record<string, unknown> = {
         message: { role: "user", parts: [{ kind: "text", text: params.message }] },
       };
@@ -720,6 +772,16 @@ export function registerTools(api: any) {
         if (query) path += (path.includes('?') ? '&' : '?') + query;
       }
 
+      // JSON-RPC operations: dispatch via a2aCall()
+      if (op.jsonrpc && op.rpc_method) {
+        const rpcParams: Record<string, unknown> = {};
+        for (const [key, val] of Object.entries(params)) {
+          if (val !== undefined) rpcParams[key] = val;
+        }
+        const result = await a2aCall(cfg, op.path, op.rpc_method, Object.keys(rpcParams).length > 0 ? rpcParams : undefined, ctx?.agentId, ctx?.sessionKey);
+        return textResult(result.data);
+      }
+
       // Build body for non-GET requests
       let body: Record<string, unknown> | undefined;
       let rawBody: string | undefined;