@wowok/agent-mcp 2.7.1 → 2.7.2

package/dist/tools/handlers/evaluation.js

@@ -1,123 +1 @@
-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 },
-    };
-}
+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(a){return{'id':a['id'],'kind':a['kind'],'owner':a['owner']??'','industry':a['industry'],'industry_confidence':a['industry_confidence']??0x0,'region':a['region'],'price_min':a['price_min']!==undefined?BigInt(a['price_min']):undefined,'price_max':a['price_max']!==undefined?BigInt(a['price_max']):undefined,'token_type':a['token_type']??'','ticket_size':a['ticket_size']??'medium','trust_score':a['trust_score']??0x32,'reputation_like_ratio':a['reputation_like_ratio']??0x1,'arbitration_independent':a['arbitration_independent']??![],'merchant_history_count':a['merchant_history_count']??0x0,'capabilities':a['capabilities'],'tags':a['tags']??[],'keywords':a['keywords']??[]};}function puzzleRawFromInput(a){return{'service':{...a['service'],'priceRaw':a['service']['priceRaw']!==undefined?BigInt(a['service']['priceRaw']):undefined,'compensation_fund':a['service']['compensation_fund']?{'balance':a['service']['compensation_fund']['balance']!==undefined?BigInt(a['service']['compensation_fund']['balance']):undefined}:undefined},'machine_nodes':a['machine_nodes'],'machine_published':a['machine_published'],'machine_paused':a['machine_paused'],'reviews':a['reviews'],'events':a['events'],'similar_services':a['similar_services']?.['map'](b=>({'price':BigInt(b['price'])})),'order_amount':a['order_amount']!==undefined?BigInt(a['order_amount']):undefined,'trust_score':a['trust_score'],'arbitration_owner':a['arbitration_owner'],'service_owner':a['service_owner'],'wip_verified':a['wip_verified'],'order_history':a['order_history'],'merchant_reputation':a['merchant_reputation']};}async function resolveInjection(a,b){const c=a?personaToInjection(await getEffectivePersona(a)):undefined;return mergeInjections(c,b);}export async function handleEvaluationOperation(a){const b=strictParse(EvaluationOperationInputSchema,a,'evaluation_operation\x20input');let c;switch(b['action']){case'arb_game':{const d=b['account']?await getEffectivePersona(b['account']):null,e=b['appetite']??d?.['layer']['preferences']?.['risk_appetite'],f=b['requirements']??d?.['layer']['requirements'];c={'action':'arb_game',...evaluateArbGame(b['status'],b['perspective'],{'risk_appetite':e,'requirements':f})};break;}case'node_game':{const g=b['account']?await getEffectivePersona(b['account']):null,h=b['appetite']??g?.['layer']['preferences']?.['risk_appetite'],i=b['requirements']??g?.['layer']['requirements'];c={'action':'node_game',...evaluateNodeGame({'current_node':b['current_node'],'perspective':b['perspective'],'appetite':h,'requirements':i,'threshold':b['threshold'],'allocation':b['allocation'],'order_amount':b['order_amount'],'compensation_fund':b['compensation_fund'],'operable':b['operable'],'waiting_on':b['waiting_on']??[]})};break;}case'capability_gap':{c={'action':'capability_gap','report':summarizeCapabilityGaps(capabilityFromInput(b['demand']),capabilityFromInput(b['service']))};break;}case'compose_service':{c={'action':'compose_service','plan':composeServicesForDemand(capabilityFromInput(b['demand']),b['services']['map'](capabilityFromInput))};break;}case'demand_match':{c={'action':'demand_match','matches':await matchDemandToServices(capabilityFromInput(b['demand_cap']),b['services'],await resolveInjection(b['account'],b['injection']))};break;}case'service_match':{c={'action':'service_match','matches':await matchServiceToDemands(capabilityFromInput(b['service_cap']),b['demands'],await resolveInjection(b['account'],b['injection']))};break;}case'service_risk':{c={'action':'service_risk','result':await assessServiceRisk(b['service_id'],puzzleRawFromInput(b['puzzle_raw']),await resolveInjection(b['account'],b['injection']),b['depth']??'preorder')};break;}default:throw new Error('Unknown\x20evaluation_operation\x20action');}return{'content':[{'type':'text','text':JSON['stringify']({'result':c})}],'structuredContent':{'result':c}};}

package/dist/tools/handlers/file-export.js

@@ -1,90 +1 @@
-import { resolve } from "path";
-import { strictParse, getEnvConfig, Guard2File_InputSchema, MachineNode2File_InputSchema, } from "../../schema/index.js";
-import { guard2file, machineNode2file, } from "@wowok/wowok";
-export async function handleGuard2File(args) {
-    const validated = strictParse(Guard2File_InputSchema, args, "guard2file input");
-    const env = getEnvConfig(validated.env);
-    try {
-        await guard2file(validated.guard, validated.file_path, validated.format || "json", env.network);
-        const result = {
-            result: {
-                status: "success",
-                data: {
-                    file_path: resolve(validated.file_path),
-                    format: validated.format || "json",
-                    guard_object: validated.guard,
-                },
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        const result = {
-            result: {
-                status: "error",
-                error: error.message,
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-}
-export async function handleMachineNode2File(args) {
-    const validated = strictParse(MachineNode2File_InputSchema, args, "machineNode2file input");
-    const env = getEnvConfig(validated.env);
-    try {
-        await machineNode2file(validated.machine, validated.file_path, validated.format || "json", env.network);
-        let node_count = undefined;
-        try {
-            const filePath = resolve(validated.file_path);
-            const fileContent = await import('fs/promises').then(fs => fs.readFile(filePath, 'utf-8'));
-            if ((validated.format || "json") === "json") {
-                const parsed = JSON.parse(fileContent);
-                if (Array.isArray(parsed)) {
-                    node_count = parsed.length;
-                }
-            }
-            else {
-                const nodeMatches = fileContent.match(/^##\s+Node:/gm);
-                node_count = nodeMatches ? nodeMatches.length : 0;
-            }
-        }
-        catch {
-            node_count = undefined;
-        }
-        const result = {
-            result: {
-                status: "success",
-                data: {
-                    file_path: resolve(validated.file_path),
-                    format: validated.format || "json",
-                    machine_object: validated.machine,
-                },
-            },
-        };
-        if (node_count !== undefined) {
-            result.result.data.node_count = node_count;
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        const result = {
-            result: {
-                status: "error",
-                error: error.message,
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-}
+import{resolve}from'path';import{strictParse,getEnvConfig,Guard2File_InputSchema,MachineNode2File_InputSchema}from'../../schema/index.js';import{guard2file,machineNode2file}from'@wowok/wowok';export async function handleGuard2File(a){const b=strictParse(Guard2File_InputSchema,a,'guard2file\x20input'),c=getEnvConfig(b['env']);try{await guard2file(b['guard'],b['file_path'],b['format']||'json',c['network']);const d={'result':{'status':'success','data':{'file_path':resolve(b['file_path']),'format':b['format']||'json','guard_object':b['guard']}}};return{'content':[{'type':'text','text':JSON['stringify'](d)}],'structuredContent':d};}catch(e){const f={'result':{'status':'error','error':e['message']}};return{'content':[{'type':'text','text':JSON['stringify'](f)}],'structuredContent':f};}}export async function handleMachineNode2File(a){const b=strictParse(MachineNode2File_InputSchema,a,'machineNode2file\x20input'),c=getEnvConfig(b['env']);try{await machineNode2file(b['machine'],b['file_path'],b['format']||'json',c['network']);let d=undefined;try{const f=resolve(b['file_path']),g=await import('fs/promises')['then'](h=>h['readFile'](f,'utf-8'));if((b['format']||'json')==='json'){const h=JSON['parse'](g);Array['isArray'](h)&&(d=h['length']);}else{const i=g['match'](/^##\s+Node:/gm);d=i?i['length']:0x0;}}catch{d=undefined;}const e={'result':{'status':'success','data':{'file_path':resolve(b['file_path']),'format':b['format']||'json','machine_object':b['machine']}}};return d!==undefined&&(e['result']['data']['node_count']=d),{'content':[{'type':'text','text':JSON['stringify'](e)}],'structuredContent':e};}catch(j){const k={'result':{'status':'error','error':j['message']}};return{'content':[{'type':'text','text':JSON['stringify'](k)}],'structuredContent':k};}}

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

@@ -1,76 +1 @@
-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 },
-    };
-}
+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(a,b){const c=[];for(const d of AUTO_PULL_TYPES){try{const e=await query_events({'type':d,'cursor':null,'limit':b,'order':'descending','no_cache':![],'network':a}),f=e?.['data'];if(Array['isArray'](f))c['push'](...f);}catch{}}return c;}export async function handleIntentRadar(a){const b=strictParse(IntentRadarInputSchema,a,'intent_radar\x20input');let c;switch(b['action']){case'save':{const d=await createIntent({'intent':b['intent'],'account':b['account'],'role':b['role'],'target_types':b['target_types']});c={'action':'save','intent':d};break;}case'list':{c={'action':'list','intents':await listIntents(b['account'])};break;}case'remove':{c={'action':'remove','removed':await removeIntent(b['id'])};break;}case'match':{let e=b['events']??[];e['length']===0x0&&(e=await pullRecentEvents(b['network'],b['limit']??0x5));e=await enrichEventsWithObjectText(e,b['network']);const f=b['intent_id']?[await matchIntent(b['intent_id'],e)]['filter'](g=>g!==null):await matchAllIntents(e,b['account']);c={'action':'match','results':f};break;}default:throw new Error('Unknown\x20intent_radar\x20action');}return{'content':[{'type':'text','text':JSON['stringify']({'result':c})}],'structuredContent':{'result':c}};}

package/dist/tools/handlers/local.js

@@ -1,53 +1 @@
-import { wrapLocalHandler } from "../shared.js";
-import { withFaucetRetry } from "../retry.js";
-import { AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, } from "../../schema/index.js";
-import { account_operation, local_mark_operation, local_info_operation, } from "@wowok/wowok";
-function deriveOpType(prefix, validated) {
-    for (const key of Object.keys(validated)) {
-        if (validated[key] !== undefined) {
-            return `${prefix}_${String(key)}`;
-        }
-    }
-    return `${prefix}_unknown`;
-}
-export const handleAccountOperation = wrapLocalHandler({
-    schema: AccountOperationSchema,
-    operationFn: withFaucetRetry(account_operation),
-    parseLabel: "account_operation input",
-    buildContext: (validated) => ({
-        operation_type: deriveOpType("account", validated),
-        data: validated,
-    }),
-});
-export const handleMarkOperation = wrapLocalHandler({
-    schema: LocalMarkOperationSchema,
-    operationFn: local_mark_operation,
-    parseLabel: "local_mark_operation input",
-    buildContext: (validated) => {
-        const ctx = {
-            operation_type: deriveOpType("mark", validated),
-            data: validated,
-        };
-        const v = validated;
-        if (v.add && Array.isArray(v.add.data) && v.add.data.length > 0) {
-            ctx.pre_warnings = [
-                "Cross-network consistency (FIX-011): LocalMark names are scoped per network. " +
-                    "When creating marks for the same logical object on different networks " +
-                    "(e.g. testnet and mainnet), use the SAME name value to keep name-based " +
-                    "references portable. Before creating a mark on mainnet, consider querying " +
-                    "testnet via query_local with network='testnet' to check for an existing " +
-                    "same-named mark and replicate it.",
-            ];
-        }
-        return ctx;
-    },
-});
-export const handleInfoOperation = wrapLocalHandler({
-    schema: LocalInfoOperationSchema,
-    operationFn: local_info_operation,
-    parseLabel: "local_info_operation input",
-    buildContext: (validated) => ({
-        operation_type: deriveOpType("local_info", validated),
-        data: validated,
-    }),
-});
+import{wrapLocalHandler}from'../shared.js';import{withFaucetRetry}from'../retry.js';import{AccountOperationSchema,LocalMarkOperationSchema,LocalInfoOperationSchema}from'../../schema/index.js';import{account_operation,local_mark_operation,local_info_operation}from'@wowok/wowok';function deriveOpType(a,b){for(const c of Object['keys'](b)){if(b[c]!==undefined)return a+'_'+String(c);}return a+'_unknown';}export const handleAccountOperation=wrapLocalHandler({'schema':AccountOperationSchema,'operationFn':withFaucetRetry(account_operation),'parseLabel':'account_operation\x20input','buildContext':a=>({'operation_type':deriveOpType('account',a),'data':a})});export const handleMarkOperation=wrapLocalHandler({'schema':LocalMarkOperationSchema,'operationFn':local_mark_operation,'parseLabel':'local_mark_operation\x20input','buildContext':a=>{const b={'operation_type':deriveOpType('mark',a),'data':a},c=a;return c['add']&&Array['isArray'](c['add']['data'])&&c['add']['data']['length']>0x0&&(b['pre_warnings']=['Cross-network\x20consistency\x20(FIX-011):\x20LocalMark\x20names\x20are\x20scoped\x20per\x20network.\x20'+'When\x20creating\x20marks\x20for\x20the\x20same\x20logical\x20object\x20on\x20different\x20networks\x20'+'(e.g.\x20testnet\x20and\x20mainnet),\x20use\x20the\x20SAME\x20name\x20value\x20to\x20keep\x20name-based\x20'+'references\x20portable.\x20Before\x20creating\x20a\x20mark\x20on\x20mainnet,\x20consider\x20querying\x20'+'testnet\x20via\x20query_local\x20with\x20network=\x27testnet\x27\x20to\x20check\x20for\x20an\x20existing\x20'+'same-named\x20mark\x20and\x20replicate\x20it.']),b;}});export const handleInfoOperation=wrapLocalHandler({'schema':LocalInfoOperationSchema,'operationFn':local_info_operation,'parseLabel':'local_info_operation\x20input','buildContext':a=>({'operation_type':deriveOpType('local_info',a),'data':a})});

package/dist/tools/handlers/messenger.js

@@ -1,188 +1 @@
-import { strictParse, MessengerOperationInputSchema, } from "../../schema/index.js";
-import { watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, pull_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, blacklist, friendslist, guardlist, settings, } from "@wowok/wowok";
-import { classifyError, buildDataSemantic, } from "../../schema/call/semantic.js";
-export function normalizeAccountOrMark(input) {
-    if (typeof input === 'string') {
-        return { name_or_address: input, local_mark_first: true };
-    }
-    return input;
-}
-export function normalizeManyAccountOrMark(input) {
-    if (Array.isArray(input)) {
-        return {
-            entities: input.map(item => typeof item === 'string' ? { name_or_address: item, local_mark_first: true } : item),
-            check_all_founded: true,
-        };
-    }
-    return input;
-}
-export async function handleMessengerOperation(args) {
-    let validated;
-    try {
-        validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
-        const opLiteral = validated.operation;
-        let result;
-        switch (validated.operation) {
-            case "watch_conversations": {
-                const conversations = await watch_conversations(validated.filter);
-                result = { operation: "watch_conversations", result: conversations };
-                break;
-            }
-            case "send_message": {
-                const sendResult = await send_message(validated.from, normalizeAccountOrMark(validated.to), validated.content, validated.options);
-                const filteredResult = {
-                    ...sendResult,
-                    merkleData: sendResult.merkleData ? {
-                        leafIndex: sendResult.merkleData.leafIndex,
-                        prevRoot: sendResult.merkleData.prevRoot,
-                        newRoot: sendResult.merkleData.newRoot,
-                        serverSignature: sendResult.merkleData.serverSignature,
-                        serverTimestamp: sendResult.merkleData.serverTimestamp,
-                        serverPublicKey: sendResult.merkleData.serverPublicKey,
-                    } : undefined,
-                };
-                result = { operation: "send_message", result: filteredResult };
-                break;
-            }
-            case "send_file": {
-                const sendResult = await send_file(validated.from, normalizeAccountOrMark(validated.to), validated.filePath, validated.options);
-                const filteredResult = {
-                    ...sendResult,
-                    merkleData: sendResult.merkleData ? {
-                        leafIndex: sendResult.merkleData.leafIndex,
-                        prevRoot: sendResult.merkleData.prevRoot,
-                        newRoot: sendResult.merkleData.newRoot,
-                        serverSignature: sendResult.merkleData.serverSignature,
-                        serverTimestamp: sendResult.merkleData.serverTimestamp,
-                        serverPublicKey: sendResult.merkleData.serverPublicKey,
-                    } : undefined,
-                };
-                result = { operation: "send_file", result: filteredResult };
-                break;
-            }
-            case "watch_messages": {
-                const filter = validated.filter ? {
-                    ...validated.filter,
-                    peerAddress: validated.filter.peerAddress ? normalizeAccountOrMark(validated.filter.peerAddress) : undefined,
-                } : undefined;
-                const messages = await watch_messages(filter);
-                result = { operation: "watch_messages", result: messages };
-                break;
-            }
-            case "extract_zip_messages": {
-                const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
-                result = { operation: "extract_zip_messages", result: extractedPaths };
-                break;
-            }
-            case "generate_wts": {
-                const params = validated.params ? {
-                    ...validated.params,
-                    peerAccount: normalizeAccountOrMark(validated.params.peerAccount),
-                } : undefined;
-                const wtsResult = await generate_wts(params);
-                result = { operation: "generate_wts", result: wtsResult };
-                break;
-            }
-            case "verify_wts": {
-                const verifyResult = await verify_wts(validated.wtsFilePath);
-                result = { operation: "verify_wts", result: verifyResult };
-                break;
-            }
-            case "sign_wts": {
-                const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
-                result = { operation: "sign_wts", result: signedPath };
-                break;
-            }
-            case "wts2html": {
-                const htmlResult = await wts2html(validated.wtsPath, validated.options);
-                result = { operation: "wts2html", result: htmlResult };
-                break;
-            }
-            case "proof_message": {
-                const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
-                result = { operation: "proof_message", result: proofResult };
-                break;
-            }
-            case "blacklist": {
-                const blacklistParams = {
-                    account: validated.account,
-                    op: validated.blacklist.op,
-                };
-                if ('users' in validated.blacklist) {
-                    blacklistParams.users = normalizeManyAccountOrMark(validated.blacklist.users);
-                }
-                const blacklistResult = await blacklist(blacklistParams);
-                result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
-                break;
-            }
-            case "friendslist": {
-                const friendslistParams = {
-                    account: validated.account,
-                    op: validated.friendslist.op,
-                };
-                if ('users' in validated.friendslist) {
-                    friendslistParams.users = normalizeManyAccountOrMark(validated.friendslist.users);
-                }
-                const friendslistResult = await friendslist(friendslistParams);
-                result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
-                break;
-            }
-            case "guardlist": {
-                const guardlistResult = await guardlist({
-                    account: validated.account,
-                    ...validated.guardlist,
-                });
-                result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
-                break;
-            }
-            case "settings": {
-                const settingsResult = await settings({
-                    account: validated.account,
-                    ...validated.settings,
-                });
-                result = { operation: "settings", op: validated.settings.op, result: settingsResult.result };
-                break;
-            }
-            case "mark_messages_as_viewed": {
-                const markedCount = await mark_messages_as_viewed(validated.messageIds, validated.account);
-                result = { operation: "mark_messages_as_viewed", result: markedCount };
-                break;
-            }
-            case "mark_conversation_as_viewed": {
-                const markedCount = await mark_conversation_as_viewed(normalizeAccountOrMark(validated.peerAddress), validated.account);
-                result = { operation: "mark_conversation_as_viewed", result: markedCount };
-                break;
-            }
-            case "pull_messages": {
-                const messages = await pull_messages(validated.account, validated.limit);
-                result = { operation: "pull_messages", result: messages };
-                break;
-            }
-            default:
-                throw new Error(`Unknown messenger operation: ${opLiteral}`);
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: { result },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const ctx = validated ? { operation_type: "messenger_" + validated.operation, data: validated } : undefined;
-        const classified = classifyError(errorMessage);
-        const errorResult = { operation: "error", error: errorMessage };
-        if (classified.error_code !== undefined)
-            errorResult.error_code = classified.error_code;
-        if (classified.retryable !== undefined)
-            errorResult.retryable = classified.retryable;
-        if (classified.recovery_hint !== undefined)
-            errorResult.recovery_hint = classified.recovery_hint;
-        return {
-            content: [{ type: "text", text: `Error: ${errorMessage}` }],
-            structuredContent: {
-                result: errorResult,
-                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
-            },
-        };
-    }
-}
+import{strictParse,MessengerOperationInputSchema}from'../../schema/index.js';import{watch_conversations,send_message,send_file,watch_messages,extract_zip_messages,pull_messages,generate_wts,verify_wts,sign_wts,wts2html,proof_message,mark_messages_as_viewed,mark_conversation_as_viewed,blacklist,friendslist,guardlist,settings}from'@wowok/wowok';import{classifyError,buildDataSemantic}from'../../schema/call/semantic.js';export function normalizeAccountOrMark(a){if(typeof a==='string')return{'name_or_address':a,'local_mark_first':!![]};return a;}export function normalizeManyAccountOrMark(a){if(Array['isArray'](a))return{'entities':a['map'](b=>typeof b==='string'?{'name_or_address':b,'local_mark_first':!![]}:b),'check_all_founded':!![]};return a;}export async function handleMessengerOperation(a){let b;try{b=strictParse(MessengerOperationInputSchema,a,'messenger_operation\x20input');const c=b['operation'];let d;switch(b['operation']){case'watch_conversations':{const e=await watch_conversations(b['filter']);d={'operation':'watch_conversations','result':e};break;}case'send_message':{const f=await send_message(b['from'],normalizeAccountOrMark(b['to']),b['content'],b['options']),g={...f,'merkleData':f['merkleData']?{'leafIndex':f['merkleData']['leafIndex'],'prevRoot':f['merkleData']['prevRoot'],'newRoot':f['merkleData']['newRoot'],'serverSignature':f['merkleData']['serverSignature'],'serverTimestamp':f['merkleData']['serverTimestamp'],'serverPublicKey':f['merkleData']['serverPublicKey']}:undefined};d={'operation':'send_message','result':g};break;}case'send_file':{const h=await send_file(b['from'],normalizeAccountOrMark(b['to']),b['filePath'],b['options']),i={...h,'merkleData':h['merkleData']?{'leafIndex':h['merkleData']['leafIndex'],'prevRoot':h['merkleData']['prevRoot'],'newRoot':h['merkleData']['newRoot'],'serverSignature':h['merkleData']['serverSignature'],'serverTimestamp':h['merkleData']['serverTimestamp'],'serverPublicKey':h['merkleData']['serverPublicKey']}:undefined};d={'operation':'send_file','result':i};break;}case'watch_messages':{const j=b['filter']?{...b['filter'],'peerAddress':b['filter']['peerAddress']?normalizeAccountOrMark(b['filter']['peerAddress']):undefined}:undefined,k=await watch_messages(j);d={'operation':'watch_messages','result':k};break;}case'extract_zip_messages':{const l=await extract_zip_messages(b['account'],b['messages'],b['outputDir']);d={'operation':'extract_zip_messages','result':l};break;}case'generate_wts':{const m=b['params']?{...b['params'],'peerAccount':normalizeAccountOrMark(b['params']['peerAccount'])}:undefined,n=await generate_wts(m);d={'operation':'generate_wts','result':n};break;}case'verify_wts':{const o=await verify_wts(b['wtsFilePath']);d={'operation':'verify_wts','result':o};break;}case'sign_wts':{const p=await sign_wts(b['wtsFilePath'],b['account'],b['outputPath']);d={'operation':'sign_wts','result':p};break;}case'wts2html':{const q=await wts2html(b['wtsPath'],b['options']);d={'operation':'wts2html','result':q};break;}case'proof_message':{const r=await proof_message(b['account'],b['messageId'],b['network']);d={'operation':'proof_message','result':r};break;}case'blacklist':{const s={'account':b['account'],'op':b['blacklist']['op']};'users'in b['blacklist']&&(s['users']=normalizeManyAccountOrMark(b['blacklist']['users']));const t=await blacklist(s);d={'operation':'blacklist','op':b['blacklist']['op'],'result':t['result']};break;}case'friendslist':{const u={'account':b['account'],'op':b['friendslist']['op']};'users'in b['friendslist']&&(u['users']=normalizeManyAccountOrMark(b['friendslist']['users']));const v=await friendslist(u);d={'operation':'friendslist','op':b['friendslist']['op'],'result':v['result']};break;}case'guardlist':{const w=await guardlist({'account':b['account'],...b['guardlist']});d={'operation':'guardlist','op':b['guardlist']['op'],'result':w['result']};break;}case'settings':{const x=await settings({'account':b['account'],...b['settings']});d={'operation':'settings','op':b['settings']['op'],'result':x['result']};break;}case'mark_messages_as_viewed':{const y=await mark_messages_as_viewed(b['messageIds'],b['account']);d={'operation':'mark_messages_as_viewed','result':y};break;}case'mark_conversation_as_viewed':{const z=await mark_conversation_as_viewed(normalizeAccountOrMark(b['peerAddress']),b['account']);d={'operation':'mark_conversation_as_viewed','result':z};break;}case'pull_messages':{const A=await pull_messages(b['account'],b['limit']);d={'operation':'pull_messages','result':A};break;}default:throw new Error('Unknown\x20messenger\x20operation:\x20'+c);}return{'content':[{'type':'text','text':JSON['stringify'](d)}],'structuredContent':{'result':d}};}catch(B){const C=B instanceof Error?B['message']:String(B),D=b?{'operation_type':'messenger_'+b['operation'],'data':b}:undefined,E=classifyError(C),F={'operation':'error','error':C};if(E['error_code']!==undefined)F['error_code']=E['error_code'];if(E['retryable']!==undefined)F['retryable']=E['retryable'];if(E['recovery_hint']!==undefined)F['recovery_hint']=E['recovery_hint'];return{'content':[{'type':'text','text':'Error:\x20'+C}],'structuredContent':{'result':F,'semantic':buildDataSemantic(undefined,D,!![],C)}};}}