@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/schema/schema-query/index.d.ts

@@ -15,19 +15,39 @@ export declare const SchemaQueryInputSchema: z.ZodObject<{
 export declare const SchemaQueryOutputSchema: z.ZodObject<{
     success: z.ZodBoolean;
     action: z.ZodString;
-    data: z.ZodAny;
+    data: z.ZodUnion<[z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        title?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        title?: string | undefined;
+    }>, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>;
     message: z.ZodString;
     suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
     message: string;
+    data: Record<string, unknown> | {
+        name: string;
+        description?: string | undefined;
+        title?: string | undefined;
+    }[] | null;
     success: boolean;
     action: string;
-    data?: any;
     suggestions?: string[] | undefined;
 }, {
     message: string;
+    data: Record<string, unknown> | {
+        name: string;
+        description?: string | undefined;
+        title?: string | undefined;
+    }[] | null;
     success: boolean;
     action: string;
-    data?: any;
     suggestions?: string[] | undefined;
 }>;

package/dist/schema/schema-query/index.js

@@ -20,13 +20,24 @@ export const SchemaQueryInputSchema = z
         .describe("Search query for 'search' action"),
 })
     .strict();
+const SchemaListItemSchema = z
+    .object({
+    name: z.string().describe("Schema/tool identifier (e.g. 'onchain_operations')."),
+    title: z.string().optional().describe("Human-readable title, if known."),
+    description: z.string().optional().describe("Short description, if known."),
+})
+    .strict();
 export const SchemaQueryOutputSchema = z
     .object({
     success: z.boolean().describe("Whether the request was successful"),
     action: z.string().describe("The action that was performed"),
     data: z
-        .any()
-        .describe("Response data - JSON Schema object for 'get'/'get_output', array of schema info for 'list'/'search'/'list_operations'"),
+        .union([
+        z.array(SchemaListItemSchema).describe("List of schema summaries (list/search/list_operations)."),
+        z.record(z.unknown()).describe("JSON Schema object (get/get_output)."),
+        z.null().describe("No data — lookup failed or returned nothing."),
+    ])
+        .describe("Response data — array of schema summaries for list-like actions, JSON Schema object for get/get_output, null on failure."),
     message: z.string().describe("Human-readable message describing the result"),
     suggestions: z
         .array(z.string())

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

@@ -0,0 +1,21 @@
+export declare const LAYER3_DIR: string;
+export declare const LAYER4_DIR: string;
+export declare const TOOLS_17: readonly string[];
+export interface SyncResult {
+    ok: number;
+    failed: number;
+    errors: Array<{
+        tool: string;
+        error: string;
+    }>;
+    layer3Dir: string;
+    layer4Dir: string;
+    total: number;
+}
+export interface SyncOptions {
+    silent?: boolean;
+    layer3Dir?: string;
+    layer4Dir?: string;
+}
+export declare function syncDeployedToolDescriptors(options?: SyncOptions): SyncResult;
+export declare function shouldAutoSyncAtStartup(): boolean;

package/dist/schema/sync-layer4.js

@@ -0,0 +1,261 @@
+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 = [
+    'onchain_operations',
+    'account_operation',
+    'local_mark_operation',
+    'local_info_operation',
+    'wip_file',
+    'messenger_operation',
+    'guard2file',
+    'machineNode2file',
+    'query_toolkit',
+    'onchain_table_data',
+    'onchain_events',
+    'wowok_buildin_info',
+    'schema_query',
+    'bridge_operation',
+    'project_operation',
+    'config_operation',
+    'trust_score',
+];
+const JSON_SCHEMA_DRAFT7 = 'http://json-schema.org/draft-07/schema#';
+function createExternalFileCache() {
+    return new Map();
+}
+function loadExternalFile(filePath, layer3Dir, cache) {
+    if (cache.has(filePath)) {
+        return cache.get(filePath);
+    }
+    const fullPath = path.resolve(layer3Dir, filePath);
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`External $ref file not found: ${fullPath}`);
+    }
+    const parsed = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+    cache.set(filePath, parsed);
+    return parsed;
+}
+function resolveRefTarget(ref, root, layer3Dir, cache) {
+    if (!ref.startsWith('#')) {
+        const [filePath, innerPath] = ref.split('#', 2);
+        const external = loadExternalFile(filePath, layer3Dir, cache);
+        if (!innerPath || innerPath === '/') {
+            return external;
+        }
+        if (!innerPath.startsWith('/')) {
+            throw new Error(`Unsupported external $ref format: ${ref}`);
+        }
+        const parts = innerPath.slice(1).split('/');
+        let target = external;
+        for (const part of parts) {
+            if (target === null || typeof target !== 'object') {
+                throw new Error(`Cannot resolve $ref part "${part}" in ${ref}`);
+            }
+            target = target[part];
+        }
+        return target;
+    }
+    if (!ref.startsWith('#/')) {
+        throw new Error(`Unsupported $ref (must start with "#/" or be external file): ${ref}`);
+    }
+    const parts = ref.slice(2).split('/');
+    let target = root;
+    for (const part of parts) {
+        if (target === null || typeof target !== 'object') {
+            return undefined;
+        }
+        target = target[part];
+    }
+    return target;
+}
+function resolveRefs(node, root, layer3Dir, cache, seen = new Set()) {
+    if (node === null || typeof node !== 'object') {
+        return node;
+    }
+    if (Array.isArray(node)) {
+        return node.map((item) => resolveRefs(item, root, layer3Dir, cache, seen));
+    }
+    if (typeof node.$ref === 'string') {
+        const ref = node.$ref;
+        if (seen.has(ref)) {
+            return { $ref: ref, description: node.description };
+        }
+        const target = resolveRefTarget(ref, root, layer3Dir, cache);
+        if (target === undefined || target === null) {
+            throw new Error(`Cannot resolve $ref target: ${ref}`);
+        }
+        const nextSeen = new Set(seen);
+        nextSeen.add(ref);
+        const externalRoot = ref.startsWith('#')
+            ? root
+            : loadExternalFile(ref.split('#', 2)[0], layer3Dir, cache);
+        const resolved = resolveRefs(target, externalRoot, layer3Dir, cache, nextSeen);
+        if (node.description && !resolved.description) {
+            resolved.description = node.description;
+        }
+        return resolved;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(node)) {
+        result[key] = resolveRefs(value, root, layer3Dir, cache, seen);
+    }
+    return result;
+}
+function extractSchemaBody(layer3, layer3Dir, cache) {
+    const rootForResolution = {
+        ...layer3,
+        definitions: layer3.definitions,
+    };
+    let body;
+    if (layer3.$ref) {
+        const ref = layer3.$ref;
+        const target = resolveRefTarget(ref, rootForResolution, layer3Dir, cache);
+        if (target === undefined || target === null) {
+            throw new Error(`Top-level $ref cannot be resolved: ${ref}`);
+        }
+        const innerRoot = ref.startsWith('#')
+            ? rootForResolution
+            : loadExternalFile(ref.split('#', 2)[0], layer3Dir, cache);
+        body = resolveRefs(target, innerRoot, layer3Dir, cache);
+    }
+    else {
+        const { $schema, $id, title, definitions, description, ...rest } = layer3;
+        body = resolveRefs(rest, rootForResolution, layer3Dir, cache);
+    }
+    return body;
+}
+function buildDeployedFile(toolName, layer3Dir, layer4Dir, cache) {
+    const l3Path = path.join(layer3Dir, `${toolName}.schema.json`);
+    const l4Path = path.join(layer4Dir, `${toolName}.json`);
+    if (!fs.existsSync(l3Path)) {
+        throw new Error(`Layer 3 schema not found: ${l3Path}`);
+    }
+    const layer3 = JSON.parse(fs.readFileSync(l3Path, 'utf-8'));
+    const body = extractSchemaBody(layer3, layer3Dir, cache);
+    const argsObj = {
+        type: body.type ?? 'object',
+        properties: body.properties ?? {},
+        required: body.required ?? [],
+        $schema: JSON_SCHEMA_DRAFT7,
+    };
+    if (body.additionalProperties !== undefined) {
+        argsObj.additionalProperties = body.additionalProperties;
+    }
+    if (body.description) {
+        argsObj.description = body.description;
+    }
+    if (body.oneOf) {
+        argsObj.oneOf = body.oneOf;
+    }
+    if (body.anyOf) {
+        argsObj.anyOf = body.anyOf;
+    }
+    if (body.allOf) {
+        argsObj.allOf = body.allOf;
+    }
+    let description = layer3.description ?? `${toolName} operation`;
+    if (fs.existsSync(l4Path)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(l4Path, 'utf-8'));
+            if (existing.description && existing.description.length > 0) {
+                description = existing.description;
+            }
+        }
+        catch {
+        }
+    }
+    if (!description.includes('schema_query')) {
+        const hint = `\n\n💡 Schema hint: Use schema_query with action='get' and name='${toolName}' ` +
+            `to retrieve the exact parameter schema before calling.`;
+        description = description + hint;
+    }
+    return {
+        name: toolName,
+        description,
+        arguments: argsObj,
+    };
+}
+export function syncDeployedToolDescriptors(options = {}) {
+    const silent = options.silent ?? false;
+    const layer3Dir = options.layer3Dir ?? LAYER3_DIR;
+    const layer4Dir = options.layer4Dir ?? LAYER4_DIR;
+    const log = (msg) => {
+        if (!silent)
+            console.log(msg);
+    };
+    const logErr = (msg) => {
+        if (!silent)
+            console.error(msg);
+    };
+    log('🔄 Syncing Layer 4 deployed tool descriptors from Layer 3 ...\n');
+    log(`Layer 3 source: ${layer3Dir}`);
+    log(`Layer 4 target:  ${layer4Dir}\n`);
+    if (!fs.existsSync(layer3Dir)) {
+        const msg = `Layer 3 directory does not exist: ${layer3Dir}`;
+        logErr(`✗ ${msg}`);
+        throw new Error(`${msg} (run 'pnpm generate:schemas' first)`);
+    }
+    if (!fs.existsSync(layer4Dir)) {
+        const msg = `Layer 4 directory does not exist: ${layer4Dir}`;
+        logErr(`✗ ${msg}`);
+        throw new Error(msg);
+    }
+    const cache = createExternalFileCache();
+    let succeeded = 0;
+    let failed = 0;
+    const failures = [];
+    for (const tool of TOOLS_17) {
+        try {
+            const deployed = buildDeployedFile(tool, layer3Dir, layer4Dir, cache);
+            const outputPath = path.join(layer4Dir, `${tool}.json`);
+            fs.writeFileSync(outputPath, JSON.stringify(deployed, null, 2) + '\n', 'utf-8');
+            const argCount = Object.keys(deployed.arguments.properties).length;
+            const requiredCount = deployed.arguments.required.length;
+            const unionType = deployed.arguments.oneOf
+                ? 'oneOf'
+                : deployed.arguments.anyOf
+                    ? 'anyOf'
+                    : deployed.arguments.allOf
+                        ? 'allOf'
+                        : '';
+            const unionInfo = unionType
+                ? ` [${unionType}=${deployed.arguments[unionType].length}]`
+                : '';
+            log(`  ✓ ${tool.padEnd(28)} props=${String(argCount).padStart(2)}  required=${String(requiredCount).padStart(2)}${unionInfo}`);
+            succeeded++;
+        }
+        catch (e) {
+            logErr(`  ✗ ${tool}: ${e.message}`);
+            failures.push({ tool, error: e.message });
+            failed++;
+        }
+    }
+    log(`\n✅ Succeeded: ${succeeded}/${TOOLS_17.length}`);
+    if (failed > 0) {
+        logErr(`❌ Failed: ${failed}`);
+        for (const f of failures) {
+            logErr(`   - ${f.tool}: ${f.error}`);
+        }
+    }
+    else {
+        log('All 17 Layer 4 deployed files are now FULL schemas (no stubs remain).');
+    }
+    return {
+        ok: succeeded,
+        failed,
+        errors: failures,
+        layer3Dir,
+        layer4Dir,
+        total: TOOLS_17.length,
+    };
+}
+export function shouldAutoSyncAtStartup() {
+    const v = process.env.WOWOK_SYNC_LAYER4;
+    if (v === undefined || v === '' || v === 'auto')
+        return true;
+    if (v === 'never' || v === '0' || v === 'false')
+        return false;
+    return true;
+}

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

@@ -69,9 +69,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                 humanReadable: string;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
-            score: number;
             summary: string;
             warnings: string[];
+            score: number;
             level: "high_risk" | "caution" | "moderate" | "trusted";
             breakdown: {
                 description: string;
@@ -80,9 +80,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                 humanReadable: string;
             }[];
         }, {
-            score: number;
             summary: string;
             warnings: string[];
+            score: number;
             level: "high_risk" | "caution" | "moderate" | "trusted";
             breakdown: {
                 description: string;
@@ -127,7 +127,6 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
             }, "strip", z.ZodTypeAny, {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -136,10 +135,10 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }, {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -148,16 +147,14 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
             advice: string[];
             level: "low" | "medium_low" | "medium_high" | "high";
-            total: number;
-            red_flags: string[];
             dimensions: {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -166,16 +163,16 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }[];
+            total: number;
+            red_flags: string[];
         }, {
             advice: string[];
             level: "low" | "medium_low" | "medium_high" | "high";
-            total: number;
-            red_flags: string[];
             dimensions: {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -184,7 +181,10 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }[];
+            total: number;
+            red_flags: string[];
         }>>;
         info_puzzle: z.ZodOptional<z.ZodObject<{
             completeness: z.ZodNumber;
@@ -201,9 +201,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
         }>>;
     }, "strip", z.ZodTypeAny, {
         trust_score: {
-            score: number;
             summary: string;
             warnings: string[];
+            score: number;
             level: "high_risk" | "caution" | "moderate" | "trusted";
             breakdown: {
                 description: string;
@@ -228,12 +228,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
         risk_score?: {
             advice: string[];
             level: "low" | "medium_low" | "medium_high" | "high";
-            total: number;
-            red_flags: string[];
             dimensions: {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -242,7 +239,10 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }[];
+            total: number;
+            red_flags: string[];
         } | undefined;
         info_puzzle?: {
             completeness: number;
@@ -251,9 +251,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
         } | undefined;
     }, {
         trust_score: {
-            score: number;
             summary: string;
             warnings: string[];
+            score: number;
             level: "high_risk" | "caution" | "moderate" | "trusted";
             breakdown: {
                 description: string;
@@ -278,12 +278,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
         risk_score?: {
             advice: string[];
             level: "low" | "medium_low" | "medium_high" | "high";
-            total: number;
-            red_flags: string[];
             dimensions: {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -292,7 +289,10 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }[];
+            total: number;
+            red_flags: string[];
         } | undefined;
         info_puzzle?: {
             completeness: number;
@@ -303,9 +303,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     result: {
         trust_score: {
-            score: number;
             summary: string;
             warnings: string[];
+            score: number;
             level: "high_risk" | "caution" | "moderate" | "trusted";
             breakdown: {
                 description: string;
@@ -330,12 +330,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
         risk_score?: {
             advice: string[];
             level: "low" | "medium_low" | "medium_high" | "high";
-            total: number;
-            red_flags: string[];
             dimensions: {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -344,7 +341,10 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }[];
+            total: number;
+            red_flags: string[];
         } | undefined;
         info_puzzle?: {
             completeness: number;
@@ -355,9 +355,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
 }, {
     result: {
         trust_score: {
-            score: number;
             summary: string;
             warnings: string[];
+            score: number;
             level: "high_risk" | "caution" | "moderate" | "trusted";
             breakdown: {
                 description: string;
@@ -382,12 +382,9 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
         risk_score?: {
             advice: string[];
             level: "low" | "medium_low" | "medium_high" | "high";
-            total: number;
-            red_flags: string[];
             dimensions: {
                 name: "fund" | "workflow" | "trust" | "behavior";
                 score: number;
-                max_score: number;
                 checks: {
                     description: string;
                     id: string;
@@ -396,7 +393,10 @@ export declare const TrustScoreOutputSchema: z.ZodObject<{
                     passed: boolean;
                     advice?: string | undefined;
                 }[];
+                max_score: number;
             }[];
+            total: number;
+            red_flags: string[];
         } | undefined;
         info_puzzle?: {
             completeness: number;