@wowok/agent-mcp 2.6.8 → 2.6.9

package/dist/tools/handlers/onchain.js

@@ -1,5 +1,6 @@
-import { readFileSync } from "fs";
-import { resolve } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { getWowMcpDir } from "@wowok/wowok";
 import { CallService, CallMachine, CallProgress, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, ResponseData, LocalProject, LocalMark, query_objects, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
 import { OnchainOperationsSchema, strictParse, getEnvConfig, handleCallResult, checkClientSchemaCompatibility, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, transformSubmission, } from "../../schema/index.js";
 import { handlePermissionOperations } from "../../schema/call/permission-handler.js";
@@ -9,6 +10,86 @@ import { getSkillsHintForOnchain } from "../../schema/utils/skills-recommendatio
 import { prepareFundOperation, generateSkillsHint as generateFundSkillsHint } from "../../knowledge/fund-layer.js";
 import { generateGuardSubmissionPrompt, formatSubmissionPrompt } from "../../knowledge/guard-submission-prompt.js";
 import { withHarness } from "../shared.js";
+const REFERRER_FILE = join(getWowMcpDir(), "referrer");
+function readStoredReferrer() {
+    try {
+        if (!existsSync(REFERRER_FILE))
+            return null;
+        const v = readFileSync(REFERRER_FILE, "utf8").trim();
+        return v || null;
+    }
+    catch {
+        return null;
+    }
+}
+const PROJECT_SKILL_DIRS = [
+    ".claude/skills",
+    ".agents/skills",
+    ".cursor/rules",
+    ".github/prompts",
+    ".windsurf/skills",
+    ".codex/skills",
+    ".qoder/skills",
+    ".roo/skills",
+    ".codebuddy/skills",
+];
+const PROJECT_SKILL_MARKERS = [
+    "wowok-provider",
+    "wowok-arbitrator",
+    "wowok-order",
+    "wowok-messenger",
+    "wowok-machine",
+    "wowok-output",
+    "wowok-onboard",
+    "wowok-planner",
+    "wowok-auditor",
+];
+const SKILLS_HINT_FILE = join(getWowMcpDir(), "skills-hint-asked.json");
+function projectHasSkills(cwd) {
+    for (const dir of PROJECT_SKILL_DIRS) {
+        for (const marker of PROJECT_SKILL_MARKERS) {
+            if (existsSync(join(cwd, dir, marker)))
+                return true;
+        }
+    }
+    return false;
+}
+function loadSkillsAsked() {
+    try {
+        if (!existsSync(SKILLS_HINT_FILE))
+            return {};
+        return JSON.parse(readFileSync(SKILLS_HINT_FILE, "utf8")) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function persistSkillsAsked(cwd) {
+    try {
+        const map = loadSkillsAsked();
+        map[cwd] = true;
+        mkdirSync(dirname(SKILLS_HINT_FILE), { recursive: true });
+        writeFileSync(SKILLS_HINT_FILE, JSON.stringify(map, null, 2), "utf8");
+    }
+    catch {
+    }
+}
+function getProjectSkillsHint() {
+    try {
+        const cwd = process.cwd();
+        if (!cwd || projectHasSkills(cwd))
+            return null;
+        const asked = loadSkillsAsked();
+        if (asked[cwd])
+            return null;
+        persistSkillsAsked(cwd);
+        return ("WoWok skills are not installed in this project. Run `wowok-skills init` " +
+            "here to install them (the MCP works regardless; skills improve AI orchestration).");
+    }
+    catch {
+        return null;
+    }
+}
 function formatRecipientLabel(recipient) {
     if (!recipient)
         return "unknown";
@@ -341,6 +422,11 @@ export async function handleOnchainOperations(args) {
         }
         validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
         const env = getEnvConfig(validated.env);
+        if (!env.referrer) {
+            const storedReferrer = readStoredReferrer();
+            if (storedReferrer)
+                env.referrer = storedReferrer;
+        }
         const clientSchemaVersion = env.client_schema_version;
         const schemaStrictMode = env.schema_strict_mode;
         const schemaCheck = clientSchemaVersion
@@ -382,6 +468,10 @@ export async function handleOnchainOperations(args) {
         if (skillsHint) {
             constraintWarnings.push(skillsHint);
         }
+        const projectSkillsHint = getProjectSkillsHint();
+        if (projectSkillsHint) {
+            constraintWarnings.push(projectSkillsHint);
+        }
         switch (validated.operation_type) {
             case "service": {
                 const data = validated.data;
@@ -907,8 +997,8 @@ export async function handleOnchainOperations(args) {
                         "CoinWrapper and transferring the underlying coin to tx_context::sender\n" +
                         "Requirements:\n" +
                         "  - You MUST be the CoinWrapper's owner (the recipient specified in the Allocation)\n" +
-                        "  - type_parameter MUST match the coin type used when the Allocation created the Payment " +
-                        "(e.g. '0x2::wow::WOW')\n" +
+                        "  - type_parameter is OPTIONAL: when omitted it is auto-derived from the CoinWrapper's " +
+                        "own on-chain type (the inner T of CoinWrapper<T>)\n" +
                         "  - object can be a CoinWrapper ID (0x...) or a local mark name\n" +
                         "To find received CoinWrappers: call query_toolkit with query_type='onchain_received' " +
                         "and type='CoinWrapper' for your account.\n" +

package/dist/tools/index.js

@@ -205,11 +205,11 @@ export const TOOL_REGISTRY = [
         handler: handleWowokInfo,
         config: {
             title: "ℹ️ WoWok Build-in Information",
-            description: "Query WoWok protocol information: 'constants', 'built-in permissions', 'common mistakes', 'guard instructions', 'current network', 'value types', or 'mainnet bridge tokens'. Use 'common mistakes' to proactively learn known field-name/unit/workflow pitfalls before submitting an operation (e.g. filter operation:\"compensation_fund_add\"). For 'mainnet bridge tokens': returns cross-chain bridge tokens (ETH, WETH, WBTC, USDC, USDT) with each token's symbol, WOW-side type tag (wowTypeTag), EVM address, decimals, and description. The wowTypeTag (format {address}::{module}::{struct}) can be used directly as the `type_parameter` of Service / Treasury / Reward / Allocation objects to set their payment token — e.g. use USDT's wowTypeTag to create a Service that accepts USDT payments.",
+            description: "Query WoWok protocol information: 'constants', 'built-in permissions', 'common mistakes', 'guard instructions', 'current network', 'value types', 'mainnet bridge tokens', or 'funding guidance'. Use 'common mistakes' to proactively learn known field-name/unit/workflow pitfalls before submitting an operation (e.g. filter operation:\"compensation_fund_add\"). For 'mainnet bridge tokens': returns cross-chain bridge tokens (ETH, WETH, WBTC, USDC, USDT) with each token's symbol, WOW-side type tag (wowTypeTag), EVM address, decimals, and description. The wowTypeTag (format {address}::{module}::{struct}) can be used directly as the `type_parameter` of Service / Treasury / Reward / Allocation objects to set their payment token — e.g. use USDT's wowTypeTag to create a Service that accepts USDT payments. For 'funding guidance': returns how to obtain WOW gas and payment tokens — testnet faucet, mainnet ETH cross-chain bridge flow, and the WOW mainnet airdrop link. Use this when a user asks how to obtain tokens/gas/funds, or as a proactive first-use reminder.",
             inputSchema: ProtocolInfoQuerySchema,
             outputSchema: ProtocolInfoResultSchema,
             annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types", "bridge-tokens"]),
+            _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types", "bridge-tokens", "funding-guidance", "faucet", "airdrop"]),
         },
     },
     {
@@ -466,7 +466,7 @@ const WOWOK_TOOL_DESCRIPTION = [
     "  query_toolkit — Query on-chain objects by ID/type/owner.",
     "  onchain_table_data — Query on-chain dynamic field tables with pagination.",
     "  onchain_events — Watch on-chain events (arbitration, order, progress, demand).",
-    "  wowok_buildin_info — Protocol constants, built-in permissions, bridge tokens.",
+    "  wowok_buildin_info — Protocol constants, built-in permissions, bridge tokens, funding guidance.",
     "  schema_query — Query JSON schemas for any sub-tool (action: list/get/get_output/search).",
     "  bridge_operation — Cross-chain bridge between WOW and EVM (mainnet only).",
     "  project_operation — Project entity management (SQLite) + 3-pathway graph + evaluation engine.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wowok/agent-mcp",
-  "version": "2.6.8",
+  "version": "2.6.9",
   "description": "Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,7 +50,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@wowok/wowok": "2.6.8",
+    "@wowok/wowok": "2.6.9",
     "lodash": "^4.18.1",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.25.2"

package/dist/examples/insurance-service-allocators-publish.json

@@ -1,56 +0,0 @@
-{
-  "title": "Add Entity-Sharing Order Allocators and Publish Insurance Service",
-  "description": "Update the unpublished insurance Service with two alternative order_allocators (Treasury collection and personal collection, first-match-wins) whose sharing recipients are FIXED Entity addresses — the fund-theft-safe pattern — then publish the Service in the same transaction.",
-  "tags": ["service", "insurance", "order_allocators", "entity-sharing", "publish"],
-  "industry": "insurance",
-  "operation_type": "service",
-  "source": "docs/examples/Insurance — schema-validated, not chain-verified",
-  "verified": false,
-  "network": "testnet",
-  "call": {
-    "tool": "onchain_operations",
-    "operation_type": "service",
-    "data": {
-      "object": "insurance_service_v1",
-      "order_allocators": {
-        "description": "Insurance order revenue allocation — 2 alternative merchant collection approaches (first-match-wins means only the first passing allocator executes)",
-        "threshold": 0,
-        "allocators": [
-          {
-            "guard": "insurance_withdraw_guard_treasury_v1",
-            "sharing": [
-              {
-                "who": { "Entity": { "name_or_address": "insurance_treasury_v1" } },
-                "sharing": 10000,
-                "mode": "Rate"
-              }
-            ]
-          },
-          {
-            "guard": "insurance_withdraw_guard_personal_v1",
-            "sharing": [
-              {
-                "who": { "Entity": { "name_or_address": "insurance_provider_v1" } },
-                "sharing": 10000,
-                "mode": "Rate"
-              }
-            ]
-          }
-        ]
-      },
-      "publish": true
-    },
-    "env": {
-      "account": "insurance_provider_v1",
-      "network": "testnet"
-    }
-  },
-  "notes": [
-    "Fund-safety pattern the library previously lacked: who = {Entity: {name_or_address: ...}} pins the recipient to a FIXED address (Treasury object or provider account) resolved via LocalMark at build time. Even if the withdraw Guard were bypassed or a forged Order submitted, funds still flow to the fixed Entity — the caller cannot redirect them. NEVER use {Signer: 'signer'} for merchant collection (funds would go to whoever triggers allocation).",
-    "first-match-wins: the TWO allocators illustrate the 2 alternative collection designs (Treasury vs personal); only the FIRST allocator whose Guard passes executes. In production pick ONE and delete the other. Each allocator's Guard must be a UNIQUE Guard object — hence two Guards with identical logic in the doc (see sibling insurance-guard-withdraw-allocation example).",
-    "Schema check (call/service.ts CallService_DataSchema + query/index.ts AllocatorsSchema/AllocatorSchema/AllocationSharingSchema/RecipientSchema): object is the STRING form (existing service); order_allocators = {description, threshold, allocators[]} with per-allocator {guard: NameOrAddress, sharing: [{who: {Entity: {name_or_address}}, sharing, mode}]}; mode 'Rate' with a single sharing of 10000 satisfies the Rate-sum == 10000 (basis points, 100%) rule with no Surplus item; threshold 0 allows any balance.",
-    "IMMUTABILITY (L1-locked): order_allocators can ONLY be set before publish=true (service.move E_ALREADY_PUBLISHED); after publish it is permanently frozen — this call sets allocators and publishes in one transaction, which is the standard finalize step.",
-    "PREREQUISITES: insurance_service_v1 created UNPUBLISHED with machine + sales (so its name resolves in the Guards' static tables); both withdraw Guards and insurance_treasury_v1 created; Machine published. This is Step 7 of the Insurance doc flow.",
-    "Desensitization: doc payload already uses generic local-mark names only (insurance_service_v1, insurance_treasury_v1, insurance_provider_v1, insurance_withdraw_guard_*_v1); no real personal data present, nothing replaced."
-  ]
-}