@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/schemas/query_task_status.output.json

@@ -0,0 +1,115 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://wowok.net/schemas/query_task_status.json",
+  "title": "Task Status - Async Operation Tracking",
+  "description": "Query the status of a long-running async task (created by build_graph or evaluate_project with async_mode=true). Returns progress percentage, current status, and the final result.",
+  "$ref": "#/definitions/query_task_status",
+  "definitions": {
+    "query_task_status": {
+      "type": "object",
+      "properties": {
+        "task_id": {
+          "type": "string",
+          "description": "The queried task ID (present when a single task was queried)."
+        },
+        "task": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "task_id": {
+                  "type": "string",
+                  "description": "Unique task identifier."
+                },
+                "operation": {
+                  "type": "string",
+                  "description": "Operation type that created this task (e.g. 'build_graph')."
+                },
+                "status": {
+                  "type": "string",
+                  "enum": [
+                    "pending",
+                    "running",
+                    "completed",
+                    "failed",
+                    "cancelled"
+                  ],
+                  "description": "Current task status."
+                },
+                "progress": {
+                  "type": "number",
+                  "description": "Progress percentage 0-100."
+                },
+                "message": {
+                  "type": "string",
+                  "description": "Human-readable progress message."
+                },
+                "result": {
+                  "anyOf": [
+                    {},
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "description": "Result payload (set when status='completed'). null otherwise."
+                },
+                "error": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "Error message (set when status='failed'). null otherwise."
+                },
+                "started_at": {
+                  "type": "number",
+                  "description": "Timestamp (ms) when the task was created."
+                },
+                "completed_at": {
+                  "type": [
+                    "number",
+                    "null"
+                  ],
+                  "description": "Timestamp (ms) when the task reached a terminal state. null if still running."
+                },
+                "project_id": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "Project ID associated with this task, if any."
+                }
+              },
+              "required": [
+                "task_id",
+                "operation",
+                "status",
+                "progress",
+                "message",
+                "error",
+                "started_at",
+                "completed_at",
+                "project_id"
+              ],
+              "additionalProperties": false
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "The task state. null if task_id not found or when listing."
+        },
+        "tasks": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/query_task_status/properties/task/anyOf/0"
+          },
+          "description": "List of tasks (present when task_id was omitted)."
+        }
+      },
+      "required": [
+        "task"
+      ],
+      "additionalProperties": false
+    }
+  }
+}

package/dist/schemas/query_task_status.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://wowok.net/schemas/query_task_status.json",
+  "title": "Task Status - Async Operation Tracking",
+  "description": "Query the status of a long-running async task (created by build_graph or evaluate_project with async_mode=true). Returns progress percentage, current status, and the final result.",
+  "$ref": "#/definitions/query_task_status",
+  "definitions": {
+    "query_task_status": {
+      "type": "object",
+      "properties": {
+        "task_id": {
+          "type": "string",
+          "description": "The task ID to query (returned by a prior async operation). If omitted, lists all recent tasks (most recent first, max 50)."
+        },
+        "project_id": {
+          "type": "string",
+          "description": "Optional filter — when listing tasks (task_id omitted), only return tasks for this project."
+        }
+      },
+      "additionalProperties": false,
+      "description": "Query the status of an async task, or list all recent tasks when task_id is omitted."
+    }
+  }
+}

package/dist/schemas/query_toolkit.output.json

@@ -2648,7 +2648,7 @@
               },
               "wip": {
                 "type": "string",
-                "description": "WIP file URL. EMPTY string \"\" skips verification (TESTING ONLY). Production MUST use a real HTTP URL pointing to a .wip file generated by the wip_file tool. Example: \"https://cdn.example.com/products/phone_v1.wip\""
+                "description": "WIP file URL. EMPTY string \"\" skips verification (TESTING ONLY). Production MUST use a real HTTP URL pointing to a .wip file generated by the wip_file tool. ⚠️ NETWORK DEPLOYMENT REQUIRED: the URL is stored ON-CHAIN and every customer fetches it when placing an order. A local file path (C:\\..., /path/file.wip), a localhost/loopback URL or a LAN private-IP URL is unreachable by customers on other machines — it passes the merchant-side set-time verification but makes order_new abort 100% for customers. Either deploy the .wip file to a public endpoint (GitHub Pages / IPFS / your own website) and set this to the public URL, or leave it empty (\"\") to skip WIP verification (TESTING ONLY). Example: \"https://cdn.example.com/products/phone_v1.wip\""
               },
               "wip_hash": {
                 "type": "string",

package/dist/schemas/trust_score.schema.json

@@ -291,7 +291,7 @@
             "metrics"
           ],
           "additionalProperties": false,
-          "description": "Optional user-controllable scoring factors (评分体系用户可控). Evaluated at depth=preorder; the composite adjustment (±cap) nudges the order confidence score."
+          "description": "Optional user-controllable scoring factors. Evaluated at depth=preorder; the composite adjustment (±cap) nudges the order confidence score."
         },
         "network": {
           "type": "string",

package/dist/tools/handlers/evaluation.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleEvaluationOperation(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/evaluation.js

@@ -0,0 +1,123 @@
+import { strictParse } from "../../schema/index.js";
+import { EvaluationOperationInputSchema } from "../../schema/evaluation/index.js";
+import { evaluateArbGame } from "../../evaluation/arbitration-game.js";
+import { evaluateNodeGame } from "../../evaluation/node-game.js";
+import { summarizeCapabilityGaps } from "../../evaluation/gap.js";
+import { composeServicesForDemand } from "../../evaluation/composer.js";
+import { matchDemandToServices, matchServiceToDemands } from "../../evaluation/builtins/demand-match.js";
+import { assessServiceRisk } from "../../evaluation/builtins/service-risk.js";
+import { registerBuiltinEvaluations } from "../../evaluation/builtins/index.js";
+import { getEffectivePersona, mergeInjections, personaToInjection } from "../../persona/index.js";
+registerBuiltinEvaluations();
+function capabilityFromInput(input) {
+    return {
+        id: input.id,
+        kind: input.kind,
+        owner: input.owner ?? "",
+        industry: input.industry,
+        industry_confidence: input.industry_confidence ?? 0,
+        region: input.region,
+        price_min: input.price_min !== undefined ? BigInt(input.price_min) : undefined,
+        price_max: input.price_max !== undefined ? BigInt(input.price_max) : undefined,
+        token_type: input.token_type ?? "",
+        ticket_size: input.ticket_size ?? "medium",
+        trust_score: input.trust_score ?? 50,
+        reputation_like_ratio: input.reputation_like_ratio ?? 1,
+        arbitration_independent: input.arbitration_independent ?? false,
+        merchant_history_count: input.merchant_history_count ?? 0,
+        capabilities: input.capabilities,
+        tags: input.tags ?? [],
+        keywords: input.keywords ?? [],
+    };
+}
+function puzzleRawFromInput(input) {
+    return {
+        service: {
+            ...input.service,
+            priceRaw: input.service.priceRaw !== undefined ? BigInt(input.service.priceRaw) : undefined,
+            compensation_fund: input.service.compensation_fund
+                ? { balance: input.service.compensation_fund.balance !== undefined ? BigInt(input.service.compensation_fund.balance) : undefined }
+                : undefined,
+        },
+        machine_nodes: input.machine_nodes,
+        machine_published: input.machine_published,
+        machine_paused: input.machine_paused,
+        reviews: input.reviews,
+        events: input.events,
+        similar_services: input.similar_services?.map((s) => ({ price: BigInt(s.price) })),
+        order_amount: input.order_amount !== undefined ? BigInt(input.order_amount) : undefined,
+        trust_score: input.trust_score,
+        arbitration_owner: input.arbitration_owner,
+        service_owner: input.service_owner,
+        wip_verified: input.wip_verified,
+        order_history: input.order_history,
+        merchant_reputation: input.merchant_reputation,
+    };
+}
+async function resolveInjection(account, explicit) {
+    const base = account ? personaToInjection(await getEffectivePersona(account)) : undefined;
+    return mergeInjections(base, explicit);
+}
+export async function handleEvaluationOperation(args) {
+    const validated = strictParse(EvaluationOperationInputSchema, args, "evaluation_operation input");
+    let result;
+    switch (validated.action) {
+        case "arb_game": {
+            result = { action: "arb_game", ...evaluateArbGame(validated.status, validated.perspective) };
+            break;
+        }
+        case "node_game": {
+            result = {
+                action: "node_game",
+                ...evaluateNodeGame({
+                    current_node: validated.current_node,
+                    perspective: validated.perspective,
+                    operable: validated.operable,
+                    waiting_on: validated.waiting_on ?? [],
+                }),
+            };
+            break;
+        }
+        case "capability_gap": {
+            result = {
+                action: "capability_gap",
+                report: summarizeCapabilityGaps(capabilityFromInput(validated.demand), capabilityFromInput(validated.service)),
+            };
+            break;
+        }
+        case "compose_service": {
+            result = {
+                action: "compose_service",
+                plan: composeServicesForDemand(capabilityFromInput(validated.demand), validated.services.map(capabilityFromInput)),
+            };
+            break;
+        }
+        case "demand_match": {
+            result = {
+                action: "demand_match",
+                matches: await matchDemandToServices(capabilityFromInput(validated.demand_cap), validated.services, await resolveInjection(validated.account, validated.injection)),
+            };
+            break;
+        }
+        case "service_match": {
+            result = {
+                action: "service_match",
+                matches: await matchServiceToDemands(capabilityFromInput(validated.service_cap), validated.demands, await resolveInjection(validated.account, validated.injection)),
+            };
+            break;
+        }
+        case "service_risk": {
+            result = {
+                action: "service_risk",
+                result: await assessServiceRisk(validated.service_id, puzzleRawFromInput(validated.puzzle_raw), await resolveInjection(validated.account, validated.injection), validated.depth ?? "preorder"),
+            };
+            break;
+        }
+        default:
+            throw new Error("Unknown evaluation_operation action");
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

package/dist/tools/handlers/intent-radar.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleIntentRadar(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/intent-radar.js

@@ -0,0 +1,76 @@
+import { strictParse } from "../../schema/index.js";
+import { IntentRadarInputSchema } from "../../schema/intent-radar/index.js";
+import { createIntent, listIntents, matchAllIntents, matchIntent, removeIntent, } from "../../intent/index.js";
+import { enrichEventsWithObjectText } from "../../intent/enrich.js";
+import { query_events } from "@wowok/wowok";
+const AUTO_PULL_TYPES = [
+    "NewOrderEvent",
+    "DemandPresentEvent",
+    "DemandFeedbackEvent",
+    "ProgressEvent",
+    "NewEntityEvent",
+    "ArbEvent",
+];
+async function pullRecentEvents(network, limit) {
+    const all = [];
+    for (const type of AUTO_PULL_TYPES) {
+        try {
+            const res = await query_events({
+                type,
+                cursor: null,
+                limit,
+                order: "descending",
+                no_cache: false,
+                network: network,
+            });
+            const data = res?.data;
+            if (Array.isArray(data))
+                all.push(...data);
+        }
+        catch {
+        }
+    }
+    return all;
+}
+export async function handleIntentRadar(args) {
+    const validated = strictParse(IntentRadarInputSchema, args, "intent_radar input");
+    let result;
+    switch (validated.action) {
+        case "save": {
+            const intent = await createIntent({
+                intent: validated.intent,
+                account: validated.account,
+                role: validated.role,
+                target_types: validated.target_types,
+            });
+            result = { action: "save", intent };
+            break;
+        }
+        case "list": {
+            result = { action: "list", intents: await listIntents(validated.account) };
+            break;
+        }
+        case "remove": {
+            result = { action: "remove", removed: await removeIntent(validated.id) };
+            break;
+        }
+        case "match": {
+            let events = validated.events ?? [];
+            if (events.length === 0) {
+                events = await pullRecentEvents(validated.network, validated.limit ?? 5);
+            }
+            events = await enrichEventsWithObjectText(events, validated.network);
+            const results = validated.intent_id
+                ? [await matchIntent(validated.intent_id, events)].filter((r) => r !== null)
+                : await matchAllIntents(events, validated.account);
+            result = { action: "match", results };
+            break;
+        }
+        default:
+            throw new Error("Unknown intent_radar action");
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

package/dist/tools/handlers/onchain.js

@@ -9,6 +9,7 @@ import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../p
 import { getSkillsHintForOnchain } from "../../schema/utils/skills-recommendation.js";
 import { prepareFundOperation, generateSkillsHint as generateFundSkillsHint } from "../../knowledge/fund-layer.js";
 import { generateGuardSubmissionPrompt, formatSubmissionPrompt } from "../../knowledge/guard-submission-prompt.js";
+import { classifyWipPath } from "../wip-deploy-assist.js";
 import { withHarness } from "../shared.js";
 const REFERRER_FILE = join(getWowMcpDir(), "referrer");
 function readStoredReferrer() {
@@ -362,6 +363,99 @@ function buildFundBlockResult(fund, operationType) {
         },
     };
 }
+function checkSalesWipNetworkDeployment(data, env, warnings) {
+    const sales = data?.sales;
+    if (!sales || typeof sales !== "object")
+        return null;
+    if (sales.op !== "add" && sales.op !== "set")
+        return null;
+    const items = Array.isArray(sales.sales) ? sales.sales : [];
+    if (items.length === 0)
+        return null;
+    const isLocalnet = env?.network === "localnet";
+    for (const sale of items) {
+        const wip = sale?.wip;
+        if (typeof wip !== "string" || wip === "")
+            continue;
+        const classification = classifyWipPath(wip);
+        if (!classification.is_local)
+            continue;
+        if (classification.type === "local_http") {
+            if (isLocalnet) {
+                warnings.push(`WIP INTERNAL-TEST-ONLY REMINDER (sale "${sale.name}"): wip = "${wip}" is a ` +
+                    `local-network URL (${classification.description}). It is reachable ONLY on the ` +
+                    `local machine / LAN where a local WIP server runs. This is acceptable for LOCALNET ` +
+                    `internal testing, but customers and on-chain verifiers on OTHER machines CANNOT ` +
+                    `reach it — on testnet/mainnet, every customer order_new would fail 100% because the ` +
+                    `WIP file cannot be verified. For any non-localnet deployment, replace this URL with ` +
+                    `a public endpoint (GitHub Pages / IPFS / your own website) or leave sale.wip empty.`);
+                continue;
+            }
+            const typeLabel = `a local-network URL (${classification.description})`;
+            const errorText = `⛔ WIP IS NOT NETWORK-DEPLOYABLE — sales NOT submitted\n\n` +
+                `Sale "${sale.name}" has wip = "${wip}", which is ${typeLabel}.\n\n` +
+                `INTERNAL TEST USE ONLY: this URL is reachable only from the merchant's own machine/LAN. ` +
+                `Customers on other machines cannot reach it, so verifying the WIP file at order time ` +
+                `fails and order_new aborts 100%. Local-network WIP URLs are allowed ONLY for ` +
+                `localnet internal testing (env.network = "localnet"); on ${env?.network ?? "this network"} ` +
+                `they must never be stored on-chain.\n\n` +
+                `Fix: deploy the .wip file to a publicly reachable endpoint, then re-run with ` +
+                `sale.wip = "<public URL>" (e.g. GitHub Pages, IPFS gateway, or your own website).\n` +
+                `  • GitHub Pages: https://<user>.github.io/<repo>/<file>.wip\n` +
+                `  • IPFS:        https://ipfs.io/ipfs/<CID>  (or ipfs://<CID>)\n` +
+                `  • Your site:   https://<your-domain>/<path>/<file>.wip\n` +
+                `Alternatively, set sale.wip = "" (empty) to SKIP WIP verification — ` +
+                `TESTING ONLY, not recommended for production.`;
+            return {
+                content: [{ type: "text", text: errorText }],
+                structuredContent: {
+                    result: {
+                        type: "error",
+                        error: `Sale "${sale.name}" wip is ${typeLabel}: ${wip}. Local-network URLs are INTERNAL TEST USE ONLY — customers cannot verify them, aborting order_new 100%.`,
+                        error_code: "wip_not_network_deployed",
+                        retryable: true,
+                        recovery_hint: "Deploy the .wip file to a public endpoint (GitHub Pages / IPFS / your own website) " +
+                            "and set sale.wip to the public URL; or set sale.wip = \"\" (empty) to skip WIP " +
+                            "verification (TESTING ONLY).",
+                        related_object: sale.name,
+                    },
+                    message: "WIP is a local-network URL (INTERNAL TEST USE ONLY) — sales not submitted. See recovery_hint.",
+                },
+            };
+        }
+        const typeLabel = `a LOCAL ${classification.type} path`;
+        const errorText = `⛔ WIP IS NOT NETWORK-DEPLOYABLE — sales NOT submitted\n\n` +
+            `Sale "${sale.name}" has wip = "${wip}", which is ${typeLabel}.\n\n` +
+            `Why this is fatal: the WIP path is stored ON-CHAIN and every customer ` +
+            `(on a different machine) fetches it when placing an order. A local path / ` +
+            `localhost / LAN URL is reachable only from YOUR machine — it passes the ` +
+            `merchant-side set-time verification but makes order_new abort 100% for customers.\n\n` +
+            `Fix: deploy the .wip file to a publicly reachable endpoint, then re-run with ` +
+            `sale.wip = "<public URL>" (e.g. GitHub Pages, IPFS gateway, or your own website).\n` +
+            `  • GitHub Pages: https://<user>.github.io/<repo>/<file>.wip\n` +
+            `  • IPFS:        https://ipfs.io/ipfs/<CID>  (or ipfs://<CID>)\n` +
+            `  • Your site:   https://<your-domain>/<path>/<file>.wip\n` +
+            `Alternatively, set sale.wip = "" (empty) to SKIP WIP verification — ` +
+            `TESTING ONLY, not recommended for production.`;
+        return {
+            content: [{ type: "text", text: errorText }],
+            structuredContent: {
+                result: {
+                    type: "error",
+                    error: `Sale "${sale.name}" wip is ${typeLabel}: ${wip}. Local WIP paths are unreachable by customers and abort order_new 100%.`,
+                    error_code: "wip_not_network_deployed",
+                    retryable: true,
+                    recovery_hint: "Deploy the .wip file to a public endpoint (GitHub Pages / IPFS / your own website) " +
+                        "and set sale.wip to the public URL; or set sale.wip = \"\" (empty) to skip WIP " +
+                        "verification (TESTING ONLY).",
+                    related_object: sale.name,
+                },
+                message: "WIP is not network-deployable — sales not submitted. See recovery_hint.",
+            },
+        };
+    }
+    return null;
+}
 export async function handleOnchainOperations(args) {
     let validated;
     let constraintWarnings = [];
@@ -479,6 +573,10 @@ export async function handleOnchainOperations(args) {
                 if (circularDepGuide) {
                     return circularDepGuide;
                 }
+                const wipDeployBlock = checkSalesWipNetworkDeployment(data, env, constraintWarnings);
+                if (wipDeployBlock) {
+                    return wipDeployBlock;
+                }
                 const fundResult = await prepareFundOperation(data, "service", env?.network);
                 if (fundResult.blockingErrors.length > 0) {
                     return buildFundBlockResult(fundResult, "service");

package/dist/tools/handlers/persona.d.ts

@@ -0,0 +1,4 @@
+import { GENERIC_PERSONA } from "../../persona/index.js";
+import type { ToolDispatchResult } from "../types.js";
+export declare function handlePersonaOperation(args: unknown): Promise<ToolDispatchResult>;
+export { GENERIC_PERSONA };

package/dist/tools/handlers/persona.js

@@ -0,0 +1,89 @@
+import { strictParse } from "../../schema/index.js";
+import { PersonaOperationInputSchema } from "../../schema/persona/index.js";
+import { GENERIC_PERSONA, analyzePersonaContext, applyAnalysisToCurrent, countPersonaLines, getEffectivePersona, getPersonaStore, listIndustryDefaults, personaToContextText, personaToInjection, syncExperienceToCurrent, validatePersona, } from "../../persona/index.js";
+export async function handlePersonaOperation(args) {
+    const validated = strictParse(PersonaOperationInputSchema, args, "persona_operation input");
+    const store = getPersonaStore();
+    let result;
+    switch (validated.action) {
+        case "get": {
+            const effective = await getEffectivePersona(validated.account, validated.industry, validated.role);
+            result = {
+                action: "get",
+                effective,
+                context_text: personaToContextText(effective),
+                injection: personaToInjection(effective),
+            };
+            break;
+        }
+        case "list": {
+            result = {
+                action: "list",
+                personas: await store.list(),
+                defaults: listIndustryDefaults(),
+            };
+            break;
+        }
+        case "set": {
+            const existing = validated.scope === "account" && validated.account
+                ? await store.get("account", validated.account)
+                : await store.get("system");
+            const persona = {
+                version: 1,
+                scope: validated.scope,
+                account: validated.scope === "account" ? validated.account : undefined,
+                role: validated.role,
+                industries: validated.industries,
+                long_term: validated.long_term ?? existing?.long_term ?? {},
+                current: validated.current ?? existing?.current ?? {},
+                updated_at: Date.now(),
+            };
+            const issues = validatePersona(persona);
+            if (issues.length > 0) {
+                throw new Error(`persona invalid: ${issues.join("; ")}`);
+            }
+            await store.put(persona);
+            result = { action: "set", persona, line_count: countPersonaLines(persona) };
+            break;
+        }
+        case "analyze": {
+            result = { action: "analyze", analysis: analyzePersonaContext(validated.context) };
+            break;
+        }
+        case "apply": {
+            const analysis = analyzePersonaContext(validated.context);
+            const persona = await applyAnalysisToCurrent(validated.scope, validated.account, analysis, validated.mode ?? "merge", validated.role, validated.industries);
+            result = {
+                action: "apply",
+                persona,
+                effective: await getEffectivePersona(validated.account, undefined, persona.role),
+                applied: analysis.suggestions,
+            };
+            break;
+        }
+        case "sync": {
+            const synced = await syncExperienceToCurrent(validated.account);
+            result = {
+                action: "sync",
+                persona: synced.persona,
+                applied: synced.applied,
+                effective: synced.effective,
+            };
+            break;
+        }
+        case "remove": {
+            const removed = validated.scope === "account" && validated.account
+                ? await store.delete("account", validated.account)
+                : await store.delete("system");
+            result = { action: "remove", removed };
+            break;
+        }
+        default:
+            throw new Error("Unknown persona_operation action");
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}
+export { GENERIC_PERSONA };