@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/schema/persona/index.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+const IndustryEnum = z.enum(["freelance", "rental", "education", "travel", "subscription", "retail"]);
+const RoleEnum = z.enum(["merchant", "user", "arbitrator"]);
+const ScopeEnum = z.enum(["system", "account"]);
+const PersonaIdentitySchema = z
+    .object({
+    region: z.string().optional(),
+    languages: z.array(z.string()).optional(),
+    self_description: z.string().optional(),
+})
+    .strict();
+const PersonaLayerSchema = z
+    .object({
+    identity: PersonaIdentitySchema.optional(),
+    preferences: z.record(z.unknown()).optional(),
+    strategy: z.array(z.string()).optional(),
+    rules: z.array(z.string()).optional(),
+    requirements: z.array(z.string()).optional(),
+    spec: z.string().optional(),
+})
+    .strict();
+const PersonaSchema = z
+    .object({
+    version: z.number(),
+    scope: ScopeEnum,
+    account: z.string().optional(),
+    role: RoleEnum,
+    industries: z.array(IndustryEnum),
+    long_term: PersonaLayerSchema,
+    current: PersonaLayerSchema,
+    updated_at: z.number(),
+})
+    .strict();
+const PersonaSourceSchema = z
+    .object({
+    scope: ScopeEnum,
+    account: z.string().optional(),
+    part: z.enum(["long_term", "current"]),
+})
+    .strict();
+const EffectivePersonaSchema = z
+    .object({
+    scope: ScopeEnum,
+    account: z.string().optional(),
+    role: RoleEnum,
+    industries: z.array(IndustryEnum),
+    layer: PersonaLayerSchema,
+    sources: z.array(PersonaSourceSchema),
+})
+    .strict();
+const PersonaAnalysisSuggestionSchema = z
+    .object({
+    field: z.string(),
+    value: z.unknown(),
+    reason: z.string(),
+})
+    .strict();
+const PersonaAnalysisSchema = z
+    .object({
+    role: RoleEnum.optional(),
+    industries: z.array(IndustryEnum),
+    preferences: z.record(z.unknown()),
+    requirements: z.array(z.string()),
+    rules: z.array(z.string()),
+    suggestions: z.array(PersonaAnalysisSuggestionSchema),
+    confidence: z.number(),
+})
+    .strict();
+export const PersonaOperationInputSchema = z.discriminatedUnion("action", [
+    z.object({
+        action: z.literal("get"),
+        account: z.string().optional().describe("Chain account address; omitted = system only."),
+        industry: IndustryEnum.optional(),
+        role: RoleEnum.optional(),
+    }).strict(),
+    z.object({
+        action: z.literal("list"),
+    }).strict(),
+    z.object({
+        action: z.literal("set"),
+        scope: ScopeEnum,
+        account: z.string().optional().describe("Required when scope=account."),
+        role: RoleEnum,
+        industries: z.array(IndustryEnum).default([]),
+        long_term: PersonaLayerSchema.optional(),
+        current: PersonaLayerSchema.optional(),
+    }).strict(),
+    z.object({
+        action: z.literal("analyze"),
+        context: z.string().describe("Free-form context: website URL, experience summary, self description, goal."),
+    }).strict(),
+    z.object({
+        action: z.literal("apply"),
+        context: z.string().describe("Free-form context whose extracted signals feed the CURRENT layer."),
+        scope: ScopeEnum,
+        account: z.string().optional(),
+        role: RoleEnum.optional(),
+        industries: z.array(IndustryEnum).optional(),
+        mode: z.enum(["merge", "replace"]).optional().describe("merge (default) unions strategy/rules/requirements into current; replace discards the existing current layer."),
+    }).strict(),
+    z.object({
+        action: z.literal("sync"),
+        account: z.string().optional().describe("Account whose behavior (experience layer) is merged into its CURRENT layer. Omit to sync the system persona."),
+    }).strict(),
+    z.object({
+        action: z.literal("remove"),
+        scope: ScopeEnum,
+        account: z.string().optional(),
+    }).strict(),
+]);
+export const PersonaOperationOutputSchema = z.discriminatedUnion("action", [
+    z.object({
+        action: z.literal("get"),
+        effective: EffectivePersonaSchema,
+        context_text: z.string(),
+        injection: z.record(z.unknown()),
+    }).strict(),
+    z.object({
+        action: z.literal("list"),
+        personas: z.array(PersonaSchema),
+        defaults: z.array(PersonaSchema),
+    }).strict(),
+    z.object({
+        action: z.literal("set"),
+        persona: PersonaSchema,
+        line_count: z.number(),
+    }).strict(),
+    z.object({
+        action: z.literal("analyze"),
+        analysis: PersonaAnalysisSchema,
+    }).strict(),
+    z.object({
+        action: z.literal("apply"),
+        persona: PersonaSchema,
+        effective: EffectivePersonaSchema,
+        applied: z.array(PersonaAnalysisSuggestionSchema),
+    }).strict(),
+    z.object({
+        action: z.literal("sync"),
+        persona: PersonaSchema,
+        applied: PersonaLayerSchema,
+        effective: EffectivePersonaSchema,
+    }).strict(),
+    z.object({
+        action: z.literal("remove"),
+        removed: z.boolean(),
+    }).strict(),
+]);

package/dist/schema/project/index.d.ts

@@ -398,6 +398,7 @@ export declare const ProjectOperationInputSchema: z.ZodObject<{
     intent?: string | undefined;
     project?: string | undefined;
     service_address?: string | undefined;
+    save?: boolean | undefined;
     context_objects?: string[] | undefined;
     include_events?: boolean | undefined;
     context_network?: "testnet" | "mainnet" | undefined;
@@ -443,7 +444,6 @@ export declare const ProjectOperationInputSchema: z.ZodObject<{
     diff_address?: string | undefined;
     diff_from_time?: number | undefined;
     diff_to_time?: number | undefined;
-    save?: boolean | undefined;
     detail_level?: "summary" | "full" | "detailed" | undefined;
     object_kind?: "guard" | "machine" | undefined;
     edit_format?: "json" | "tree_outline" | undefined;
@@ -578,6 +578,7 @@ export declare const ProjectOperationInputSchema: z.ZodObject<{
     intent?: string | undefined;
     project?: string | undefined;
     service_address?: string | undefined;
+    save?: boolean | undefined;
     context_objects?: string[] | undefined;
     include_events?: boolean | undefined;
     context_network?: "testnet" | "mainnet" | undefined;
@@ -623,7 +624,6 @@ export declare const ProjectOperationInputSchema: z.ZodObject<{
     diff_address?: string | undefined;
     diff_from_time?: number | undefined;
     diff_to_time?: number | undefined;
-    save?: boolean | undefined;
     detail_level?: "summary" | "full" | "detailed" | undefined;
     object_kind?: "guard" | "machine" | undefined;
     edit_format?: "json" | "tree_outline" | undefined;

package/dist/schema/query/index.js

@@ -120,6 +120,12 @@ export const ServiceSaleSchema = z.object({
     suspension: z.boolean().describe("Whether sale is suspended"),
     wip: z.string().describe("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: z.string().describe("SHA-256 hash (hex string) of the sale's WIP file, committed on-chain by the merchant. " +
         "BUY RULE: if this is NON-EMPTY, the buyer MUST pass this exact value as wip_hash when creating an order " +

package/dist/schema/sync-layer4.d.ts

@@ -1,6 +1,6 @@
 export declare const LAYER3_DIR: string;
 export declare const LAYER4_DIR: string;
-export declare const TOOLS_17: readonly string[];
+export declare const ALL_TOOLS: readonly string[];
 export interface SyncResult {
     ok: number;
     failed: number;

package/dist/schema/sync-layer4.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 export const LAYER3_DIR = path.resolve('d:/wowok/agent/mcp/dist/schemas');
 export const LAYER4_DIR = path.resolve('c:/Users/zhou/.trae-cn/mcps/s_wowok-7838e181/solo_agent/mcp_wagent/tools');
-export const TOOLS_17 = [
+export const ALL_TOOLS = [
     'onchain_operations',
     'account_operation',
     'local_mark_operation',
@@ -20,6 +20,10 @@ export const TOOLS_17 = [
     'project_operation',
     'config_operation',
     'trust_score',
+    'query_task_status',
+    'evaluation_operation',
+    'persona_operation',
+    'intent_radar',
 ];
 const JSON_SCHEMA_DRAFT7 = 'http://json-schema.org/draft-07/schema#';
 const RECURSIVE_EXTERNAL_FILES = new Set(['guard-node-schema.json']);
@@ -227,7 +231,7 @@ export function syncDeployedToolDescriptors(options = {}) {
     let succeeded = 0;
     let failed = 0;
     const failures = [];
-    for (const tool of TOOLS_17) {
+    for (const tool of ALL_TOOLS) {
         try {
             const deployed = buildDeployedFile(tool, layer3Dir, layer4Dir, cache);
             const outputPath = path.join(layer4Dir, `${tool}.json`);
@@ -253,7 +257,7 @@ export function syncDeployedToolDescriptors(options = {}) {
             failed++;
         }
     }
-    log(`\n✅ Succeeded: ${succeeded}/${TOOLS_17.length}`);
+    log(`\n✅ Succeeded: ${succeeded}/${ALL_TOOLS.length}`);
     if (failed > 0) {
         logErr(`❌ Failed: ${failed}`);
         for (const f of failures) {
@@ -261,7 +265,7 @@ export function syncDeployedToolDescriptors(options = {}) {
         }
     }
     else {
-        log('All 17 Layer 4 deployed files are now FULL schemas (no stubs remain).');
+        log(`All ${ALL_TOOLS.length} Layer 4 deployed files are now FULL schemas (no stubs remain).`);
     }
     return {
         ok: succeeded,
@@ -269,7 +273,7 @@ export function syncDeployedToolDescriptors(options = {}) {
         errors: failures,
         layer3Dir,
         layer4Dir,
-        total: TOOLS_17.length,
+        total: ALL_TOOLS.length,
     };
 }
 export function shouldAutoSyncAtStartup() {

package/dist/schema/task-status.d.ts

@@ -0,0 +1,168 @@
+import { z } from "zod";
+export declare const QueryTaskStatusInputSchema: z.ZodObject<{
+    task_id: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    project_id?: string | undefined;
+    task_id?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    task_id?: string | undefined;
+}>;
+export declare const TaskStateSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    operation: z.ZodString;
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    progress: z.ZodNumber;
+    message: z.ZodString;
+    result: z.ZodNullable<z.ZodUnknown>;
+    error: z.ZodNullable<z.ZodString>;
+    started_at: z.ZodNumber;
+    completed_at: z.ZodNullable<z.ZodNumber>;
+    project_id: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    status: "failed" | "completed" | "pending" | "cancelled" | "running";
+    error: string | null;
+    operation: string;
+    progress: number;
+    completed_at: number | null;
+    project_id: string | null;
+    task_id: string;
+    started_at: number;
+    result?: unknown;
+}, {
+    message: string;
+    status: "failed" | "completed" | "pending" | "cancelled" | "running";
+    error: string | null;
+    operation: string;
+    progress: number;
+    completed_at: number | null;
+    project_id: string | null;
+    task_id: string;
+    started_at: number;
+    result?: unknown;
+}>;
+export declare const QueryTaskStatusOutputSchema: z.ZodObject<{
+    task_id: z.ZodOptional<z.ZodString>;
+    task: z.ZodNullable<z.ZodObject<{
+        task_id: z.ZodString;
+        operation: z.ZodString;
+        status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+        progress: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodNullable<z.ZodUnknown>;
+        error: z.ZodNullable<z.ZodString>;
+        started_at: z.ZodNumber;
+        completed_at: z.ZodNullable<z.ZodNumber>;
+        project_id: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }>>;
+    tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        task_id: z.ZodString;
+        operation: z.ZodString;
+        status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+        progress: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodNullable<z.ZodUnknown>;
+        error: z.ZodNullable<z.ZodString>;
+        started_at: z.ZodNumber;
+        completed_at: z.ZodNullable<z.ZodNumber>;
+        project_id: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    task: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    } | null;
+    task_id?: string | undefined;
+    tasks?: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }[] | undefined;
+}, {
+    task: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    } | null;
+    task_id?: string | undefined;
+    tasks?: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }[] | undefined;
+}>;

package/dist/schema/task-status.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export const QueryTaskStatusInputSchema = z
+    .object({
+    task_id: z
+        .string()
+        .optional()
+        .describe("The task ID to query (returned by a prior async operation). " +
+        "If omitted, lists all recent tasks (most recent first, max 50)."),
+    project_id: z
+        .string()
+        .optional()
+        .describe("Optional filter — when listing tasks (task_id omitted), only return tasks for this project."),
+})
+    .strict()
+    .describe("Query the status of an async task, or list all recent tasks when task_id is omitted.");
+export const TaskStateSchema = z
+    .object({
+    task_id: z.string().describe("Unique task identifier."),
+    operation: z.string().describe("Operation type that created this task (e.g. 'build_graph')."),
+    status: z.enum(["pending", "running", "completed", "failed", "cancelled"]).describe("Current task status."),
+    progress: z.number().describe("Progress percentage 0-100."),
+    message: z.string().describe("Human-readable progress message."),
+    result: z.unknown().nullable().describe("Result payload (set when status='completed'). null otherwise."),
+    error: z.string().nullable().describe("Error message (set when status='failed'). null otherwise."),
+    started_at: z.number().describe("Timestamp (ms) when the task was created."),
+    completed_at: z.number().nullable().describe("Timestamp (ms) when the task reached a terminal state. null if still running."),
+    project_id: z.string().nullable().describe("Project ID associated with this task, if any."),
+})
+    .strict();
+export const QueryTaskStatusOutputSchema = z
+    .object({
+    task_id: z.string().optional().describe("The queried task ID (present when a single task was queried)."),
+    task: TaskStateSchema.nullable().describe("The task state. null if task_id not found or when listing."),
+    tasks: z.array(TaskStateSchema).optional().describe("List of tasks (present when task_id was omitted)."),
+})
+    .strict();

package/dist/schema/trust/index.js

@@ -110,7 +110,7 @@ export const TrustScoreInputSchema = z
         "If omitted at depth=preorder, the industry is inferred from the puzzle."),
     preferences: PreorderPreferencesInputSchema.optional().describe("Optional user preference overrides (partial; merged over profile-derived defaults). " +
         "Only used at depth=preorder for preference matching and pref-aware strategies."),
-    user_metrics: UserMetricsInputSchema.optional().describe("Optional user-controllable scoring factors (评分体系用户可控). " +
+    user_metrics: UserMetricsInputSchema.optional().describe("Optional user-controllable scoring factors. " +
         "Evaluated at depth=preorder; the composite adjustment (±cap) nudges the order confidence score."),
     network: z
         .string()