@ton-agent-kit/plugin-identity 1.0.0

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@ton-agent-kit/plugin-identity",
+  "version": "1.0.0",
+  "description": "Identity plugin for TON Agent Kit — agent registry, discovery, and reputation",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": { "build": "tsc" },
+  "dependencies": {
+    "@ton-agent-kit/core": "^1.0.0",
+    "@ton/ton": "^16.2.0",
+    "@ton/core": "^0.63.1"
+  },
+  "keywords": ["ton", "blockchain", "ai", "agent", "sdk"],
+  "license": "MIT",
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "https://github.com/Andy00L/ton-agent-kit.git" }
+}

package/src/actions/discover-agent.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { Address } from "@ton/core";
+import { defineAction, toFriendlyAddress } from "@ton-agent-kit/core";
+import { loadAgentRegistry } from "../utils";
+
+export const discoverAgentAction = defineAction({
+  name: "discover_agent",
+  description:
+    "Find registered agents by capability or name. Search the local agent registry to find agents that can perform specific tasks.",
+  schema: z.object({
+    capability: z
+      .string()
+      .optional()
+      .describe("Capability to search for (e.g., 'price_feed', 'trading')"),
+    name: z.string().optional().describe("Agent name to search for"),
+  }),
+  handler: async (agent, params) => {
+    const registry = loadAgentRegistry();
+    let results = Object.values(registry);
+
+    if (params.capability) {
+      const cap = params.capability.toLowerCase();
+      results = results.filter((a: any) =>
+        a.capabilities.some((c: string) => c.toLowerCase().includes(cap)),
+      );
+    }
+
+    if (params.name) {
+      const name = params.name.toLowerCase();
+      results = results.filter((a: any) =>
+        a.name.toLowerCase().includes(name),
+      );
+    }
+
+    return {
+      query: { capability: params.capability, name: params.name },
+      count: results.length,
+      agents: results.map((a: any) => ({
+        id: a.id,
+        name: a.name,
+        address: a.address,
+        friendlyAddress: toFriendlyAddress(Address.parse(a.address), agent.network),
+        capabilities: a.capabilities,
+        description: a.description,
+        endpoint: a.endpoint,
+        reputation: a.reputation,
+        registeredAt: a.registeredAt,
+      })),
+    };
+  },
+});

package/src/actions/get-agent-reputation.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { Address } from "@ton/core";
+import { defineAction, toFriendlyAddress } from "@ton-agent-kit/core";
+import { loadAgentRegistry, saveAgentRegistry } from "../utils";
+
+export const getAgentReputationAction = defineAction({
+  name: "get_agent_reputation",
+  description:
+    "Get the reputation score of a registered agent. Set addTask=true and success=true to record a successful task. Set addTask=true and success=false to record a failed task.",
+  schema: z.object({
+    agentId: z.string().describe("Agent ID to check or update"),
+    addTask: z
+      .union([z.boolean(), z.string()])
+      .optional()
+      .describe("Set to true to record a completed task"),
+    success: z
+      .union([z.boolean(), z.string()])
+      .optional()
+      .describe("If addTask is true, whether the task was successful"),
+  }),
+  handler: async (agent, params) => {
+    const registry = loadAgentRegistry();
+    const agentRecord = registry[params.agentId];
+    if (!agentRecord) throw new Error(`Agent not found: ${params.agentId}`);
+
+    // Coerce string booleans
+    const addTask = typeof params.addTask === "string" ? params.addTask === "true" : params.addTask;
+    const success = typeof params.success === "string" ? params.success === "true" : params.success;
+
+    // Update reputation if recording a task
+    if (addTask) {
+      agentRecord.reputation.totalTasks += 1;
+      if (success !== false) {
+        agentRecord.reputation.successfulTasks += 1;
+      }
+      agentRecord.reputation.score = Math.round(
+        (agentRecord.reputation.successfulTasks /
+          agentRecord.reputation.totalTasks) *
+          100,
+      );
+      saveAgentRegistry(registry);
+    }
+
+    return {
+      agentId: params.agentId,
+      name: agentRecord.name,
+      address: agentRecord.address,
+      friendlyAddress: toFriendlyAddress(Address.parse(agentRecord.address), agent.network),
+      reputation: agentRecord.reputation,
+      registeredAt: agentRecord.registeredAt,
+    };
+  },
+});

package/src/actions/register-agent.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { defineAction, toFriendlyAddress } from "@ton-agent-kit/core";
+import { loadAgentRegistry, saveAgentRegistry } from "../utils";
+
+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, "-")}`;
+
+    // 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());
+      }
+    } 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 registry = loadAgentRegistry();
+    registry[agentId] = agentRecord;
+    saveAgentRegistry(registry);
+
+    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)`,
+    };
+  },
+});

package/src/index.ts

@@ -0,0 +1,21 @@
+import { definePlugin } from "@ton-agent-kit/core";
+import { registerAgentAction } from "./actions/register-agent";
+import { discoverAgentAction } from "./actions/discover-agent";
+import { getAgentReputationAction } from "./actions/get-agent-reputation";
+
+/**
+ * Identity Plugin — Agent registry, discovery, and reputation
+ *
+ * Actions:
+ * - register_agent: Register an AI agent with capabilities
+ * - discover_agent: Find agents by capability or name
+ * - get_agent_reputation: Get/update agent reputation scores
+ */
+const IdentityPlugin = definePlugin({
+  name: "identity",
+  actions: [registerAgentAction, discoverAgentAction, getAgentReputationAction],
+});
+
+export default IdentityPlugin;
+
+export { registerAgentAction, discoverAgentAction, getAgentReputationAction };

package/src/utils.ts

@@ -0,0 +1,22 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+const REGISTRY_FILE = ".agent-registry.json";
+
+export function loadAgentRegistry(): Record<string, any> {
+  try {
+    if (existsSync(REGISTRY_FILE)) {
+      return JSON.parse(readFileSync(REGISTRY_FILE, "utf-8"));
+    }
+  } catch (err: any) {
+    console.error(`Failed to load agent registry: ${err.message}`);
+  }
+  return {};
+}
+
+export function saveAgentRegistry(registry: Record<string, any>): void {
+  try {
+    writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2), "utf-8");
+  } catch (err: any) {
+    console.error(`Failed to save agent registry: ${err.message}`);
+  }
+}