@ton-agent-kit/plugin-identity 1.0.0 → 1.1.0

package/src/actions/process-pending-ratings.ts

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { defineAction } from "@ton-agent-kit/core";
+
+export const processPendingRatingsAction = defineAction({
+  name: "process_pending_ratings",
+  description:
+    "Process pending reputation ratings left by completed escrow deals. Each escrow completion (release, auto-release, refund) creates pending ratings for both buyer and seller. Call this to review or auto-submit them.",
+  schema: z.object({
+    autoSubmit: z
+      .boolean()
+      .optional()
+      .describe("Automatically submit all pending ratings with suggested success values. Defaults to false (returns pending list for review)."),
+  }),
+  handler: async (agent, params) => {
+    // Load pending ratings from memory
+    let entries: any[] = [];
+    try {
+      const r = await (agent as any).runAction("list_context", {
+        namespace: "pending_ratings",
+      });
+      entries = r.entries || [];
+    } catch {
+      return {
+        processed: 0,
+        pending: 0,
+        ratings: [],
+        message: "Memory plugin not available. Cannot process pending ratings.",
+      };
+    }
+
+    if (entries.length === 0) {
+      return {
+        processed: 0,
+        pending: 0,
+        ratings: [],
+        message: "No pending ratings to process.",
+      };
+    }
+
+    // Parse entries
+    const pending: any[] = [];
+    for (const entry of entries) {
+      try {
+        const data = JSON.parse(entry.value);
+        pending.push({ ...data, memoryKey: entry.key });
+      } catch {
+        continue;
+      }
+    }
+
+    if (!params.autoSubmit) {
+      return {
+        processed: 0,
+        pending: pending.length,
+        ratings: pending.map((p) => ({
+          escrowId: p.escrowId,
+          raterRole: p.raterRole,
+          targetAddress: p.targetAddress,
+          suggestedSuccess: p.suggestedSuccess,
+          escrowOutcome: p.escrowOutcome,
+        })),
+        message: `${pending.length} pending rating(s) found. Set autoSubmit=true to submit them.`,
+      };
+    }
+
+    // Auto-submit ratings
+    let processed = 0;
+    const results: any[] = [];
+
+    for (const rating of pending) {
+      try {
+        // Find the target agent ID by address match in the registry
+        // Use a simple name-based lookup: the target address is stored in the rating
+        await (agent as any).runAction("get_agent_reputation", {
+          agentId: rating.targetAddress,
+          addTask: true,
+          success: rating.suggestedSuccess,
+        });
+
+        // Delete the processed rating from memory
+        try {
+          await (agent as any).runAction("delete_context", {
+            key: rating.memoryKey,
+            namespace: "pending_ratings",
+          });
+        } catch {}
+
+        processed++;
+        results.push({
+          escrowId: rating.escrowId,
+          raterRole: rating.raterRole,
+          targetAddress: rating.targetAddress,
+          success: rating.suggestedSuccess,
+          submitted: true,
+        });
+      } catch (err: any) {
+        results.push({
+          escrowId: rating.escrowId,
+          raterRole: rating.raterRole,
+          targetAddress: rating.targetAddress,
+          submitted: false,
+          error: err.message,
+        });
+      }
+    }
+
+    return {
+      processed,
+      pending: pending.length - processed,
+      ratings: results,
+      message: `Processed ${processed}/${pending.length} ratings.`,
+    };
+  },
+});

package/src/actions/register-agent.ts

@@ -1,69 +1,125 @@
 import { z } from "zod";
-import { defineAction, toFriendlyAddress } from "@ton-agent-kit/core";
+import { Address, internal, toNano } from "@ton/core";
+import { defineAction, toFriendlyAddress, sendTransaction } from "@ton-agent-kit/core";
 import { loadAgentRegistry, saveAgentRegistry } from "../utils";
+import { resolveContractAddress } from "../reputation-config";
+import { buildRegisterBody } from "../reputation-helpers";
 
-export const registerAgentAction = defineAction({
-  name: "register_agent",
-  description:
-    "Register an AI agent in the local agent registry with its capabilities, name, and description. Other agents can discover it via discover_agent.",
-  schema: z.object({
-    name: z
-      .string()
-      .describe("Agent name (e.g., 'market-data', 'trading-bot')"),
-    capabilities: z
-      .union([z.array(z.string()), z.string()])
-      .describe(
-        "List of capabilities (e.g., ['price_feed', 'analytics', 'trading'])",
-      ),
-    description: z
-      .string()
-      .optional()
-      .describe("Human-readable description of the agent"),
-    endpoint: z
-      .string()
-      .optional()
-      .describe("API endpoint where the agent can be reached"),
-  }),
-  handler: async (agent, params) => {
-    const agentId = `agent_${params.name.toLowerCase().replace(/[^a-z0-9]/g, "-")}`;
+export function createRegisterAgentAction(contractAddress?: string) {
+  return defineAction({
+    name: "register_agent",
+    description:
+      "Register an AI agent with its capabilities, name, and description. Other agents can discover it via discover_agent. Supports both on-chain (Tact contract) and local JSON modes.",
+    schema: z.object({
+      name: z
+        .string()
+        .describe("Agent name (e.g., 'market-data', 'trading-bot')"),
+      capabilities: z
+        .union([z.array(z.string()), z.string()])
+        .describe("List of capabilities (e.g., ['price_feed', 'analytics', 'trading'])"),
+      description: z.string().optional().describe("Human-readable description of the agent"),
+      endpoint: z.string().optional().describe("API endpoint where the agent can be reached"),
+      available: z
+        .boolean()
+        .optional()
+        .describe("Whether the agent is currently available. Defaults to true."),
+    }),
+    handler: async (agent, params) => {
+      const agentId = `agent_${params.name.toLowerCase().replace(/[^a-z0-9]/g, "-")}`;
 
-    // Coerce string capabilities to array
-    let capabilities: string[];
-    if (typeof params.capabilities === "string") {
-      try {
-        capabilities = JSON.parse(params.capabilities);
-      } catch {
-        capabilities = params.capabilities.split(",").map((c: string) => c.trim());
+      // Coerce capabilities
+      let capabilities: string[];
+      if (typeof params.capabilities === "string") {
+        try {
+          capabilities = JSON.parse(params.capabilities);
+        } catch {
+          capabilities = params.capabilities.split(",").map((c: string) => c.trim());
+        }
+      } else {
+        capabilities = params.capabilities;
       }
-    } else {
-      capabilities = params.capabilities;
-    }
 
-    const agentRecord = {
-      id: agentId,
-      name: params.name,
-      address: agent.wallet.address.toRawString(),
-      capabilities,
-      description: params.description || "",
-      endpoint: params.endpoint || null,
-      network: agent.network,
-      registeredAt: new Date().toISOString(),
-      reputation: { score: 0, totalTasks: 0, successfulTasks: 0 },
-    };
+      const available = params.available !== false;
 
-    const registry = loadAgentRegistry();
-    registry[agentId] = agentRecord;
-    saveAgentRegistry(registry);
+      // Resolve contract address (factory → config → default → null)
+      const addr = resolveContractAddress(contractAddress, agent.network);
 
-    return {
-      agentId,
-      name: params.name,
-      address: agent.wallet.address.toRawString(),
-      friendlyAddress: toFriendlyAddress(agent.wallet.address, agent.network),
-      capabilities,
-      description: params.description || "",
-      status: "registered",
-      dnsHint: `${params.name}.agents.ton (requires TON DNS domain)`,
-    };
-  },
-});
+      // Always save to JSON registry (needed for discovery — contract doesn't store names/capabilities)
+      const agentRecord = {
+        id: agentId,
+        name: params.name,
+        address: agent.wallet.address.toRawString(),
+        capabilities,
+        description: params.description || "",
+        endpoint: params.endpoint || null,
+        available,
+        network: agent.network,
+        registeredAt: new Date().toISOString(),
+        reputation: { score: 0, totalTasks: 0, successfulTasks: 0 },
+      };
+
+      const registry = loadAgentRegistry();
+      registry[agentId] = agentRecord;
+      saveAgentRegistry(registry);
+
+      // ── On-chain mode ──
+      if (addr) {
+        try {
+          const capStr = capabilities.join(",");
+          const body = buildRegisterBody(params.name, capStr, available);
+
+          await sendTransaction(agent, [
+            internal({
+              to: Address.parse(addr),
+              value: toNano("0.03"),
+              bounce: true,
+              body,
+            }),
+          ]);
+
+          return {
+            agentId,
+            name: params.name,
+            address: agent.wallet.address.toRawString(),
+            friendlyAddress: toFriendlyAddress(agent.wallet.address, agent.network),
+            capabilities,
+            available,
+            onChain: true,
+            contractAddress: addr,
+            status: "registered (on-chain + local)",
+            message: `Agent "${params.name}" registered on-chain at ${addr.slice(0, 16)}... and locally`,
+          };
+        } catch (err: any) {
+          // On-chain failed but JSON saved — return partial success
+          return {
+            agentId,
+            name: params.name,
+            address: agent.wallet.address.toRawString(),
+            friendlyAddress: toFriendlyAddress(agent.wallet.address, agent.network),
+            capabilities,
+            available,
+            onChain: false,
+            status: "registered (local only — on-chain failed)",
+            message: `Agent "${params.name}" saved locally. On-chain registration failed: ${err.message?.slice(0, 80)}`,
+          };
+        }
+      }
+
+      // ── JSON-only mode ──
+      return {
+        agentId,
+        name: params.name,
+        address: agent.wallet.address.toRawString(),
+        friendlyAddress: toFriendlyAddress(agent.wallet.address, agent.network),
+        capabilities,
+        available,
+        onChain: false,
+        description: params.description || "",
+        status: "registered",
+        dnsHint: `${params.name}.agents.ton (requires TON DNS domain)`,
+      };
+    },
+  });
+}
+
+export const registerAgentAction = createRegisterAgentAction();

package/src/actions/trigger-cleanup.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { Address, internal, toNano, beginCell } from "@ton/core";
+import { defineAction, sendTransaction } from "@ton-agent-kit/core";
+import { resolveContractAddress } from "../reputation-config";
+import { storeTriggerCleanup } from "../contracts/Reputation_Reputation";
+
+export const triggerCleanupAction = defineAction({
+  name: "trigger_cleanup",
+  description:
+    "Manually trigger cleanup of inactive, ghost, or low-score agents from the reputation contract. " +
+    "Cleanup also runs automatically on every registration and rating. " +
+    "Conditions: score<20 with 100+ ratings, inactive 30+ days, ghost (0 ratings after 7 days).",
+  schema: z.object({
+    maxClean: z.coerce.number().optional().describe("Max agents to clean. Default 10, max 50."),
+  }),
+  handler: async (agent, params) => {
+    const addr = resolveContractAddress(undefined, agent.network);
+    if (!addr) {
+      return { triggered: false, message: "No reputation contract configured" };
+    }
+
+    const maxClean = Math.min(params.maxClean || 10, 50);
+    const body = beginCell()
+      .store(storeTriggerCleanup({ $$type: "TriggerCleanup", maxClean: BigInt(maxClean) }))
+      .endCell();
+
+    await sendTransaction(agent, [
+      internal({
+        to: Address.parse(addr),
+        value: toNano("0.03"),
+        bounce: true,
+        body,
+      }),
+    ]);
+
+    return {
+      triggered: true,
+      maxClean,
+      contractAddress: addr,
+      message: `Cleanup triggered for up to ${maxClean} agents.`,
+    };
+  },
+});

package/src/actions/withdraw-reputation-fees.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { Address, internal, toNano } from "@ton/core";
+import { defineAction, sendTransaction } from "@ton-agent-kit/core";
+import { loadReputationConfig } from "../reputation-config";
+import { buildWithdrawBody } from "../reputation-helpers";
+
+export function createWithdrawReputationFeesAction(contractAddress?: string) {
+  return defineAction({
+    name: "withdraw_reputation_fees",
+    description:
+      "Withdraw accumulated fees from the on-chain Reputation contract. Only the contract owner (deployer) can call this.",
+    schema: z.object({
+      confirm: z.boolean().optional().describe("Set to true to confirm the withdrawal. Defaults to true."),
+    }),
+    handler: async (agent, _params) => {
+      const addr = contractAddress || loadReputationConfig()?.contractAddress;
+      if (!addr) {
+        return {
+          withdrawn: false,
+          message: "No reputation contract deployed. Run deploy_reputation_contract first.",
+        };
+      }
+
+      try {
+        const body = buildWithdrawBody();
+
+        await sendTransaction(agent, [
+          internal({
+            to: Address.parse(addr),
+            value: toNano("0.02"),
+            bounce: true,
+            body,
+          }),
+        ]);
+
+        return {
+          withdrawn: true,
+          contractAddress: addr,
+          message: `Withdrawal sent to reputation contract ${addr.slice(0, 16)}...`,
+        };
+      } catch (err: any) {
+        return {
+          withdrawn: false,
+          error: err.message,
+          message: `Failed to withdraw: ${err.message}`,
+        };
+      }
+    },
+  });
+}
+
+export const withdrawReputationFeesAction = createWithdrawReputationFeesAction();