@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/schema/evaluation/index.js

@@ -0,0 +1,356 @@
+import { z } from "zod";
+const RiskLevelEnum = z.enum(["low", "medium", "high"]);
+const PerspectiveEnum = z.enum(["customer", "operator", "observer"]);
+const ArbStatusEnum = z.enum([
+    "Principal_confirming",
+    "Arbitrator_confirming",
+    "Voting",
+    "Arbitrated",
+    "Objectionable",
+    "Finished",
+    "Withdrawn",
+]);
+const ArbPerspectiveEnum = z.enum(["disputant", "arbitrator", "voter", "both"]);
+const ExecutionPathEnum = z.enum(["order_holder", "permission", "named_operator", "not_available"]);
+const EvaluationLevelEnum = z.enum(["low", "medium_low", "medium_high", "high"]);
+const IndustryEnum = z.enum([
+    "freelance", "rental", "education", "travel", "subscription", "retail", "general", "custom",
+]);
+const RegionSchema = z
+    .object({
+    mode: z.enum(["remote", "physical"]),
+    country: z.string().optional(),
+    province: z.string().optional(),
+    city: z.string().optional(),
+    raw: z.string().describe("Original location string (for traceability)."),
+})
+    .strict();
+const WorkflowCapabilitiesSchema = z
+    .object({
+    has_arbitration: z.boolean(),
+    has_refund_path: z.boolean(),
+    has_milestone_nodes: z.boolean(),
+    has_compensation_fund: z.boolean(),
+    has_wip_verification: z.boolean(),
+    has_messenger: z.boolean(),
+    has_buy_guard: z.boolean(),
+    has_dynamic_pricing: z.boolean(),
+    is_published: z.boolean(),
+    is_paused: z.boolean(),
+})
+    .strict();
+export const CapabilityVectorSchema = z
+    .object({
+    id: z.string().describe("Service/Demand address."),
+    kind: z.enum(["service", "demand"]).describe("Whether this is a service or demand."),
+    owner: z.string().optional(),
+    industry: IndustryEnum.describe("Industry scenario."),
+    industry_confidence: z.number().min(0).max(1).optional(),
+    region: RegionSchema,
+    price_min: z.string().optional().describe("Smallest-unit amount (string to avoid JSON bigint loss)."),
+    price_max: z.string().optional().describe("Smallest-unit amount (string to avoid JSON bigint loss)."),
+    token_type: z.string().optional(),
+    ticket_size: z.enum(["micro", "small", "medium", "large"]).optional(),
+    trust_score: z.number().min(0).max(100).optional(),
+    reputation_like_ratio: z.number().min(0).max(1).optional(),
+    arbitration_independent: z.boolean().optional(),
+    merchant_history_count: z.number().int().min(0).optional(),
+    capabilities: WorkflowCapabilitiesSchema,
+    tags: z.array(z.string()).optional(),
+    keywords: z.array(z.string()).optional(),
+})
+    .strict();
+const ServiceExtractInputSchema = z
+    .object({
+    object: z.string().describe("Service object address."),
+    description: z.string(),
+    location: z.string(),
+    sales: z
+        .array(z.object({
+        name: z.string().optional(),
+        price: z.string().describe("Smallest-unit amount (string)."),
+        wip_hash: z.string().optional(),
+    }).strict())
+        .optional(),
+    arbitrations: z.array(z.string()).optional(),
+    compensation_fund: z.string().optional().describe("Smallest-unit amount (string)."),
+    buy_guard: z.string().nullable().optional(),
+    machine: z.string().nullable().optional(),
+    um: z.string().nullable().optional(),
+    bPublished: z.boolean().optional(),
+    bPaused: z.boolean().optional(),
+    owner: z.string().optional(),
+})
+    .strict();
+const DemandExtractInputSchema = z
+    .object({
+    object: z.string().describe("Demand object address."),
+    description: z.string(),
+    location: z.string(),
+    rewards: z.array(z.string()).optional(),
+    um: z.string().nullable().optional(),
+    owner: z.string().optional(),
+})
+    .strict();
+const UserInjectionSchema = z
+    .object({
+    intent: z.string().optional().describe("Free-text intent."),
+    preferences: z.record(z.unknown()).optional(),
+    requirements: z
+        .array(z.object({
+        rule_id: z.string(),
+        condition: z.enum(["require", "forbid"]),
+        note: z.string().optional(),
+    }).strict())
+        .optional()
+        .describe("Hard red lines (block when violated)."),
+    overrides: z
+        .object({
+        rules: z.record(z.object({ enabled: z.boolean().optional(), weight: z.number().optional() }).strict()).optional(),
+        data_sources: z.record(z.object({ enabled: z.boolean().optional() }).strict()).optional(),
+    })
+        .strict()
+        .optional()
+        .describe("Enable/disable/reweight rules and data sources."),
+})
+    .strict();
+const ArbGameActionSchema = z
+    .object({
+    action: z.string().describe("Recommended move (e.g. 'confirm', 'vote', 'objection', 'arb_withdraw')."),
+    favorability: z.number().int().min(0).max(100).describe("Favorability 0-100 for the perspective."),
+    is_optimal: z.boolean().describe("True when this is the top recommended move."),
+    payoff_note: z.string().describe("What the move achieves."),
+    risk: RiskLevelEnum.describe("Risk of the move."),
+})
+    .strict();
+const NodeForwardSchema = z
+    .object({
+    name: z.string().describe("Forward (operation) name."),
+    to_node: z.string().describe("Target node after execution."),
+    execution_path: ExecutionPathEnum.describe("How the account may execute it."),
+    guard: z.string().optional().describe("Guard address gating this forward."),
+    consequence: z.string().optional().describe("Consequence hint (completion/refund path)."),
+})
+    .strict();
+const NodeGameActionSchema = z
+    .object({
+    forward: z.string().describe("Forward (operation) name."),
+    to_node: z.string().describe("Target node after execution."),
+    execution_path: ExecutionPathEnum.describe("How the account may execute it."),
+    guard: z.string().optional().describe("Guard address gating this forward."),
+    favorability: z.number().int().min(0).max(100).describe("Favorability 0-100 for the perspective."),
+    is_optimal: z.boolean().describe("True when this is the top recommended move."),
+    payoff_note: z.string().describe("What the move achieves."),
+    risk: RiskLevelEnum.describe("Risk of the move."),
+})
+    .strict();
+const CapabilityGapSchema = z
+    .object({
+    dimension: z.string().describe("Capability dimension (has_arbitration / region / price / ...)."),
+    requirement: z.string().describe("What the demand requires."),
+    provided: z.string().describe("What the service provides."),
+    status: z.enum(["satisfied", "partial", "missing"]),
+    impact: z.enum(["critical", "major", "minor"]),
+    suggestion: z.string().describe("Actionable suggestion."),
+})
+    .strict();
+const CapabilityGapReportSchema = z
+    .object({
+    entity_id: z.string(),
+    satisfied: z.array(CapabilityGapSchema),
+    missing: z.array(CapabilityGapSchema),
+    coverage_score: z.number().int().min(0).max(100),
+    summary: z.string(),
+})
+    .strict();
+const CompositePlanSchema = z
+    .object({
+    demand: z.string(),
+    services: z.array(z.object({ id: z.string(), covered: z.array(z.string()) }).strict()),
+    coverage_score: z.number().int().min(0).max(100),
+    remaining_missing: z.array(z.string()),
+    feasibility: z.enum(["ready", "needs_supply_chain", "infeasible"]),
+    summary: z.string(),
+})
+    .strict();
+const EvaluationResultSchema = z
+    .object({
+    evaluation_id: z.string(),
+    total: z.number().int().min(0).max(100),
+    level: EvaluationLevelEnum,
+    breakdown: z.array(z.object({
+        rule_id: z.string(),
+        dimension: z.string(),
+        score: z.number(),
+        weight: z.number(),
+        reason: z.string().optional(),
+        matched: z.array(z.string()).optional(),
+        mismatched: z.array(z.string()).optional(),
+        red_flag: z.boolean().optional(),
+    }).strict()),
+    red_flags: z.array(z.string()),
+    blocked: z.boolean(),
+    trace: z.array(z.object({
+        kind: z.enum(["data_source", "rule", "override"]),
+        id: z.string(),
+        detail: z.string(),
+    }).strict()),
+    summary: z.string(),
+})
+    .strict();
+const ServiceRawDataSchema = z
+    .object({
+    name: z.string().optional(),
+    bPublished: z.boolean().optional(),
+    bPaused: z.boolean().optional(),
+    price: z.string().optional(),
+    priceRaw: z.string().optional().describe("Smallest-unit amount (string)."),
+    token_type: z.string().optional(),
+    sales: z.array(z.object({
+        suspension: z.boolean().optional(),
+        wip_url: z.string().optional(),
+        wip_hash: z.string().optional(),
+    }).strict()).optional(),
+    machine: z.string().optional(),
+    buy_guard: z.string().optional(),
+    customer_required: z.array(z.unknown()).optional(),
+    arbitrations: z.array(z.string()).optional(),
+    compensation_fund: z.object({
+        balance: z.string().optional().describe("Smallest-unit amount (string)."),
+    }).strict().optional(),
+    compensation_lock_duration: z.number().optional(),
+    um: z.string().optional(),
+})
+    .strict();
+const MachineNodeRawSchema = z
+    .object({
+    name: z.string(),
+    forwards: z.array(z.object({
+        name: z.string().optional(),
+        weight: z.number().optional(),
+        namedOperator: z.string().nullable().optional(),
+        guard: z.string().nullable().optional(),
+        to: z.string().optional(),
+    }).strict()).optional(),
+    is_pair_done: z.boolean().optional(),
+})
+    .strict();
+const ReviewRawSchema = z
+    .object({
+    rating: z.string().optional(),
+    reviewer: z.string().optional(),
+    verified: z.boolean().optional(),
+    has_evidence: z.boolean().optional(),
+    timestamp: z.number().optional(),
+})
+    .strict();
+const EventRawSchema = z
+    .object({
+    type: z.string(),
+    timestamp: z.number().optional(),
+    address: z.string().optional(),
+    data: z.record(z.unknown()).optional(),
+})
+    .strict();
+export const PuzzleRawDataSchema = z
+    .object({
+    service: ServiceRawDataSchema,
+    machine_nodes: z.array(MachineNodeRawSchema).optional(),
+    machine_published: z.boolean().optional(),
+    machine_paused: z.boolean().optional(),
+    reviews: z.array(ReviewRawSchema).optional(),
+    events: z.array(EventRawSchema).optional(),
+    similar_services: z.array(z.object({ price: z.string() }).strict()).optional(),
+    order_amount: z.string().optional().describe("Smallest-unit amount (string)."),
+    trust_score: z.object({ score: z.number(), level: z.string() }).strict().optional(),
+    arbitration_owner: z.string().optional(),
+    service_owner: z.string().optional(),
+    wip_verified: z.boolean().optional(),
+    order_history: z.array(z.object({ status: z.string(), has_dispute: z.boolean(), is_repeat: z.boolean() }).strict()).optional(),
+    merchant_reputation: z.object({ likes: z.number(), dislikes: z.number() }).strict().optional(),
+})
+    .strict();
+export const EvaluationOperationInputSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("arb_game"), status: ArbStatusEnum, perspective: ArbPerspectiveEnum }).strict(),
+    z.object({
+        action: z.literal("node_game"),
+        current_node: z.string(),
+        perspective: PerspectiveEnum,
+        operable: z.array(NodeForwardSchema),
+        waiting_on: z.array(z.object({ role: z.string(), forwards: z.array(z.string()) }).strict()).optional(),
+    }).strict(),
+    z.object({
+        action: z.literal("capability_gap"),
+        demand: CapabilityVectorSchema,
+        service: CapabilityVectorSchema,
+    }).strict(),
+    z.object({
+        action: z.literal("compose_service"),
+        demand: CapabilityVectorSchema,
+        services: z.array(CapabilityVectorSchema),
+    }).strict(),
+    z.object({
+        action: z.literal("demand_match"),
+        demand_cap: CapabilityVectorSchema,
+        services: z.array(ServiceExtractInputSchema),
+        injection: UserInjectionSchema.optional(),
+        account: z.string().optional().describe("Account address; its persona is auto-applied as the base injection (explicit injection overrides)."),
+    }).strict(),
+    z.object({
+        action: z.literal("service_match"),
+        service_cap: CapabilityVectorSchema,
+        demands: z.array(DemandExtractInputSchema),
+        injection: UserInjectionSchema.optional(),
+        account: z.string().optional().describe("Account address; its persona is auto-applied as the base injection."),
+    }).strict(),
+    z.object({
+        action: z.literal("service_risk"),
+        service_id: z.string().describe("Service object address or LocalMark name."),
+        puzzle_raw: PuzzleRawDataSchema,
+        injection: UserInjectionSchema.optional(),
+        depth: z.enum(["browse", "evaluate", "preorder", "monitor"]).optional(),
+        account: z.string().optional().describe("Account address; its persona is auto-applied as the base injection."),
+    }).strict(),
+]);
+export const EvaluationOperationOutputSchema = z
+    .object({
+    result: z
+        .discriminatedUnion("action", [
+        z.object({
+            action: z.literal("arb_game"),
+            status: ArbStatusEnum,
+            perspective: ArbPerspectiveEnum,
+            actions: z.array(ArbGameActionSchema),
+            summary: z.string(),
+        }).strict(),
+        z.object({
+            action: z.literal("node_game"),
+            current_node: z.string(),
+            perspective: PerspectiveEnum,
+            actions: z.array(NodeGameActionSchema),
+            summary: z.string(),
+        }).strict(),
+        z.object({
+            action: z.literal("capability_gap"),
+            report: CapabilityGapReportSchema,
+        }).strict(),
+        z.object({
+            action: z.literal("compose_service"),
+            plan: CompositePlanSchema,
+        }).strict(),
+        z.object({
+            action: z.literal("demand_match"),
+            matches: z.array(z.object({ service: ServiceExtractInputSchema, result: EvaluationResultSchema }).strict()),
+        }).strict(),
+        z.object({
+            action: z.literal("service_match"),
+            matches: z.array(z.object({ demand: DemandExtractInputSchema, result: EvaluationResultSchema }).strict()),
+        }).strict(),
+        z.object({
+            action: z.literal("service_risk"),
+            result: EvaluationResultSchema,
+        }).strict(),
+    ])
+        .describe("Evaluation result — shape depends on action"),
+})
+    .strict();

package/dist/schema/index.d.ts

@@ -9,6 +9,10 @@ export * from './utils/node-parser.js';
 export * from './project/index.js';
 export * from './config/index.js';
 export * from './trust/index.js';
+export * from './evaluation/index.js';
+export * from './task-status.js';
+export * from './persona/index.js';
+export * from './intent-radar/index.js';
 export * from './schema-query/index.js';
 export { MCP_SCHEMA_VERSION, getSchemaVersions, checkClientSchemaCompatibility, attachSchemaWarning, } from './schema-version.js';
 export type { SchemaVersions, SchemaCompatibilityMode, SchemaCheckOptions, SchemaCheckResult, } from './schema-version.js';

package/dist/schema/index.js

@@ -9,5 +9,9 @@ export * from './utils/node-parser.js';
 export * from './project/index.js';
 export * from './config/index.js';
 export * from './trust/index.js';
+export * from './evaluation/index.js';
+export * from './task-status.js';
+export * from './persona/index.js';
+export * from './intent-radar/index.js';
 export * from './schema-query/index.js';
 export { MCP_SCHEMA_VERSION, getSchemaVersions, checkClientSchemaCompatibility, attachSchemaWarning, } from './schema-version.js';

package/dist/schema/intent-radar/index.d.ts

@@ -0,0 +1,284 @@
+import { z } from "zod";
+export declare const IntentRadarInputSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+    action: z.ZodLiteral<"save">;
+    intent: z.ZodString;
+    account: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodEnum<["merchant", "user", "arbitrator"]>>;
+    target_types: z.ZodOptional<z.ZodArray<z.ZodEnum<["NewOrderEvent", "ProgressEvent", "DemandPresentEvent", "DemandFeedbackEvent", "NewEntityEvent", "ArbEvent"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    intent: string;
+    action: "save";
+    account?: string | undefined;
+    role?: "user" | "merchant" | "arbitrator" | undefined;
+    target_types?: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[] | undefined;
+}, {
+    intent: string;
+    action: "save";
+    account?: string | undefined;
+    role?: "user" | "merchant" | "arbitrator" | undefined;
+    target_types?: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[] | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    account: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    action: "list";
+    account?: string | undefined;
+}, {
+    action: "list";
+    account?: string | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"remove">;
+    id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    action: "remove";
+}, {
+    id: string;
+    action: "remove";
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"match">;
+    intent_id: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+    events: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    action: "match";
+    network?: "testnet" | "mainnet" | undefined;
+    account?: string | undefined;
+    events?: Record<string, unknown>[] | undefined;
+    limit?: number | undefined;
+    intent_id?: string | undefined;
+}, {
+    action: "match";
+    network?: "testnet" | "mainnet" | undefined;
+    account?: string | undefined;
+    events?: Record<string, unknown>[] | undefined;
+    limit?: number | undefined;
+    intent_id?: string | undefined;
+}>]>;
+export declare const IntentRadarOutputSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+    action: z.ZodLiteral<"save">;
+    intent: z.ZodObject<{
+        id: z.ZodString;
+        intent: z.ZodString;
+        account: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<["merchant", "user", "arbitrator"]>>;
+        industries: z.ZodArray<z.ZodEnum<["freelance", "rental", "education", "travel", "subscription", "retail", "general", "custom"]>, "many">;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        target_types: z.ZodArray<z.ZodEnum<["NewOrderEvent", "ProgressEvent", "DemandPresentEvent", "DemandFeedbackEvent", "NewEntityEvent", "ArbEvent"]>, "many">;
+        created_at: z.ZodNumber;
+        updated_at: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    }, {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    intent: {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    };
+    action: "save";
+}, {
+    intent: {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    };
+    action: "save";
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    intents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        intent: z.ZodString;
+        account: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<["merchant", "user", "arbitrator"]>>;
+        industries: z.ZodArray<z.ZodEnum<["freelance", "rental", "education", "travel", "subscription", "retail", "general", "custom"]>, "many">;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        target_types: z.ZodArray<z.ZodEnum<["NewOrderEvent", "ProgressEvent", "DemandPresentEvent", "DemandFeedbackEvent", "NewEntityEvent", "ArbEvent"]>, "many">;
+        created_at: z.ZodNumber;
+        updated_at: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    }, {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    action: "list";
+    intents: {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    }[];
+}, {
+    action: "list";
+    intents: {
+        id: string;
+        intent: string;
+        keywords: string[];
+        industries: ("custom" | "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general")[];
+        updated_at: number;
+        target_types: ("NewOrderEvent" | "ArbEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent")[];
+        created_at: number;
+        account?: string | undefined;
+        role?: "user" | "merchant" | "arbitrator" | undefined;
+    }[];
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"remove">;
+    removed: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    action: "remove";
+    removed: boolean;
+}, {
+    action: "remove";
+    removed: boolean;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"match">;
+    results: z.ZodArray<z.ZodObject<{
+        intent_id: z.ZodString;
+        intent: z.ZodString;
+        hits: z.ZodArray<z.ZodObject<{
+            event_type: z.ZodString;
+            event_id: z.ZodString;
+            related_objects: z.ZodArray<z.ZodString, "many">;
+            business_meaning: z.ZodString;
+            score: z.ZodNumber;
+            matched_industries: z.ZodArray<z.ZodString, "many">;
+            matched_keywords: z.ZodArray<z.ZodString, "many">;
+            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            event_type: string;
+            business_meaning: string;
+            score: number;
+            event: Record<string, unknown>;
+            matched_keywords: string[];
+            event_id: string;
+            related_objects: string[];
+            matched_industries: string[];
+        }, {
+            event_type: string;
+            business_meaning: string;
+            score: number;
+            event: Record<string, unknown>;
+            matched_keywords: string[];
+            event_id: string;
+            related_objects: string[];
+            matched_industries: string[];
+        }>, "many">;
+        scanned: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        intent: string;
+        intent_id: string;
+        hits: {
+            event_type: string;
+            business_meaning: string;
+            score: number;
+            event: Record<string, unknown>;
+            matched_keywords: string[];
+            event_id: string;
+            related_objects: string[];
+            matched_industries: string[];
+        }[];
+        scanned: number;
+    }, {
+        intent: string;
+        intent_id: string;
+        hits: {
+            event_type: string;
+            business_meaning: string;
+            score: number;
+            event: Record<string, unknown>;
+            matched_keywords: string[];
+            event_id: string;
+            related_objects: string[];
+            matched_industries: string[];
+        }[];
+        scanned: number;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    action: "match";
+    results: {
+        intent: string;
+        intent_id: string;
+        hits: {
+            event_type: string;
+            business_meaning: string;
+            score: number;
+            event: Record<string, unknown>;
+            matched_keywords: string[];
+            event_id: string;
+            related_objects: string[];
+            matched_industries: string[];
+        }[];
+        scanned: number;
+    }[];
+}, {
+    action: "match";
+    results: {
+        intent: string;
+        intent_id: string;
+        hits: {
+            event_type: string;
+            business_meaning: string;
+            score: number;
+            event: Record<string, unknown>;
+            matched_keywords: string[];
+            event_id: string;
+            related_objects: string[];
+            matched_industries: string[];
+        }[];
+        scanned: number;
+    }[];
+}>]>;