@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/knowledge/guard-submission-prompt.d.ts

@@ -0,0 +1,31 @@
+export interface SubmissionFieldPrompt {
+    identifier: number;
+    name: string;
+    value_type: string;
+    required: boolean;
+    suggested_value?: string;
+    suggestion_reason?: string;
+    description: string;
+}
+export interface GuardSubmissionPrompt {
+    guard_address: string;
+    guard_name?: string;
+    operation: string;
+    required_fields: SubmissionFieldPrompt[];
+    context: string;
+    fill_example: string;
+}
+export interface SubmissionContext {
+    operation: string;
+    network?: string;
+    signer?: string;
+    progress_address?: string;
+    progress_current?: string;
+    order_address?: string;
+    service_address?: string;
+    machine_address?: string;
+    allocation_address?: string;
+    extra?: Record<string, string>;
+}
+export declare function generateGuardSubmissionPrompt(guardRef: string, ctx: SubmissionContext): Promise<GuardSubmissionPrompt | undefined>;
+export declare function formatSubmissionPrompt(prompt: GuardSubmissionPrompt): string;

package/dist/knowledge/guard-submission-prompt.js

@@ -0,0 +1,171 @@
+import { query_objects, LocalMark } from "@wowok/wowok";
+function inferValue(fieldName, valueType, ctx) {
+    const name = fieldName.toLowerCase();
+    if (name.includes("order") || name.includes("task")) {
+        if (ctx.order_address) {
+            return { value: ctx.order_address, reason: "Inferred from operation's order_address context" };
+        }
+        if (ctx.progress_address) {
+            return { value: ctx.progress_address, reason: "Progress.task is typically the order — query Progress to get the actual task address" };
+        }
+    }
+    if (name.includes("signer") || name.includes("sender") || name.includes("caller")) {
+        if (ctx.signer) {
+            return { value: ctx.signer, reason: "Inferred from env.account (the signing account)" };
+        }
+    }
+    if (name.includes("service")) {
+        if (ctx.service_address) {
+            return { value: ctx.service_address, reason: "Inferred from operation's service_address context" };
+        }
+    }
+    if (name.includes("machine")) {
+        if (ctx.machine_address) {
+            return { value: ctx.machine_address, reason: "Inferred from operation's machine_address context" };
+        }
+    }
+    if (name.includes("progress") || name.includes("node") || name.includes("current")) {
+        if (ctx.progress_current) {
+            return { value: ctx.progress_current, reason: "Inferred from Progress.current node name" };
+        }
+    }
+    if (name.includes("allocation") || name.includes("allocator")) {
+        if (ctx.allocation_address) {
+            return { value: ctx.allocation_address, reason: "Inferred from operation's allocation_address context" };
+        }
+    }
+    if (ctx.extra) {
+        for (const [key, val] of Object.entries(ctx.extra)) {
+            if (name.includes(key.toLowerCase())) {
+                return { value: val, reason: `Inferred from extra context: ${key}` };
+            }
+        }
+    }
+    return undefined;
+}
+function describeField(name, valueType) {
+    const n = name.toLowerCase();
+    if (n.includes("order"))
+        return `Order object address (type: ${valueType})`;
+    if (n.includes("signer") || n.includes("sender"))
+        return `Transaction signer address (type: ${valueType})`;
+    if (n.includes("service"))
+        return `Service object address (type: ${valueType})`;
+    if (n.includes("machine"))
+        return `Machine object address (type: ${valueType})`;
+    if (n.includes("progress"))
+        return `Progress object address (type: ${valueType})`;
+    if (n.includes("node") || n.includes("current"))
+        return `Current node name (type: ${valueType})`;
+    if (n.includes("amount") || n.includes("price") || n.includes("balance"))
+        return `Amount in smallest unit (type: ${valueType})`;
+    if (n.includes("allocation"))
+        return `Allocation object address (type: ${valueType})`;
+    return `Field "${name}" (type: ${valueType})`;
+}
+export async function generateGuardSubmissionPrompt(guardRef, ctx) {
+    let guardAddress = guardRef;
+    let guardName;
+    if (!guardRef.startsWith("0x")) {
+        try {
+            const mark = await LocalMark.Instance().get(guardRef);
+            if (mark?.address) {
+                guardAddress = mark.address;
+                guardName = guardRef;
+            }
+            else {
+                return undefined;
+            }
+        }
+        catch {
+            return undefined;
+        }
+    }
+    let guardObj;
+    try {
+        const result = await query_objects({
+            objects: [guardAddress],
+            network: ctx.network,
+        });
+        guardObj = result?.objects?.[0];
+    }
+    catch {
+        return undefined;
+    }
+    if (!guardObj)
+        return undefined;
+    const table = guardObj.table ?? guardObj.b_table ?? [];
+    if (!Array.isArray(table) || table.length === 0)
+        return undefined;
+    const submissionItems = table.filter((item) => item.b_submission === true);
+    if (submissionItems.length === 0)
+        return undefined;
+    const requiredFields = submissionItems.map((item) => {
+        const fieldName = item.name ?? `identifier_${item.identifier}`;
+        const valueType = typeof item.value_type === "number"
+            ? ValueTypeNames[item.value_type] ?? String(item.value_type)
+            : String(item.value_type);
+        const inferred = inferValue(fieldName, valueType, ctx);
+        return {
+            identifier: item.identifier,
+            name: fieldName,
+            value_type: valueType,
+            required: true,
+            suggested_value: inferred?.value,
+            suggestion_reason: inferred?.reason,
+            description: describeField(fieldName, valueType),
+        };
+    });
+    const fillLines = requiredFields.map((f) => {
+        const val = f.suggested_value ?? `<${f.value_type}_value>`;
+        return `      { identifier: ${f.identifier}, name: "${f.name}", value_type: "${f.value_type}", value: ${val} }`;
+    });
+    const fillExample = `submission: {
+    guard: "${guardName ?? guardAddress}",
+    submission: [
+${fillLines.join(",\n")}
+    ]
+  }`;
+    return {
+        guard_address: guardAddress,
+        guard_name: guardName,
+        operation: ctx.operation,
+        required_fields: requiredFields,
+        context: `Operation "${ctx.operation}" requires Guard "${guardName ?? guardAddress}" verification. ` +
+            `The Guard has ${requiredFields.length} field(s) that need submission data (b_submission=true). ` +
+            `Fill the submission with the required values and retry the operation using call_with_submission. ` +
+            `Each field has an identifier (number), name, and expected value_type. ` +
+            `The suggested_value (if provided) is inferred from the operation context — verify before using.`,
+        fill_example: fillExample,
+    };
+}
+export function formatSubmissionPrompt(prompt) {
+    const lines = [];
+    lines.push("GUARD SUBMISSION REQUIRED — operation cannot proceed without submission data.");
+    lines.push(`Guard: ${prompt.guard_name ?? prompt.guard_address} (${prompt.guard_address})`);
+    lines.push(`Operation: ${prompt.operation}`);
+    lines.push("");
+    lines.push("Required fields (fill these in the submission):");
+    for (const f of prompt.required_fields) {
+        lines.push(`  [${f.identifier}] ${f.name} (${f.value_type}) — ${f.description}`);
+        if (f.suggested_value) {
+            lines.push(`      Suggested: ${f.suggested_value} (${f.suggestion_reason})`);
+        }
+        else {
+            lines.push(`      No suggestion — derive value from context or ask user.`);
+        }
+    }
+    lines.push("");
+    lines.push("Fill example (use in the next call with submission):");
+    lines.push(prompt.fill_example);
+    return lines.join("\n");
+}
+const ValueTypeNames = {
+    0: "Bool",
+    1: "Address",
+    2: "U64",
+    3: "String",
+    4: "Vec",
+    5: "U256",
+    6: "Object",
+};

package/dist/knowledge/guard-templates.d.ts

@@ -34,5 +34,15 @@ export declare function validateTemplateParams(templateId: string, params: Recor
     valid: boolean;
     missing: string[];
 };
+export type FillGuardTemplateResult = {
+    ok: true;
+    table: unknown;
+    root: unknown;
+} | {
+    ok: false;
+    error: string;
+    missing?: string[];
+};
+export declare function fillGuardTemplate(templateId: string, params: Record<string, unknown>): FillGuardTemplateResult;
 export declare const GUARD_TEMPLATES_VERSION = "1.0.0";
 export declare const GUARD_TEMPLATES_COUNT: number;

package/dist/knowledge/guard-templates.js

@@ -1051,5 +1051,55 @@ export function validateTemplateParams(templateId, params) {
         .map((p) => p.name);
     return { valid: missing.length === 0, missing };
 }
+function deepSubstitute(obj, params) {
+    if (typeof obj === "string") {
+        const full = obj.match(/^\$\{(\w+)\}$/);
+        if (full && full[1] in params) {
+            return params[full[1]];
+        }
+        return obj.replace(/\$\{(\w+)\}/g, (_, key) => key in params ? String(params[key]) : `\${${key}}`);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepSubstitute(item, params));
+    }
+    if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            result[k] = deepSubstitute(v, params);
+        }
+        return result;
+    }
+    return obj;
+}
+export function fillGuardTemplate(templateId, params) {
+    const template = getTemplateById(templateId);
+    if (!template) {
+        return { ok: false, error: `Template not found: ${templateId}` };
+    }
+    const { valid, missing } = validateTemplateParams(templateId, params);
+    if (!valid) {
+        return {
+            ok: false,
+            error: `Missing required parameters: ${missing.join(", ")}`,
+            missing,
+        };
+    }
+    const filled = { ...params };
+    for (const p of template.parameters) {
+        if (!(p.name in filled) && p.default !== undefined) {
+            filled[p.name] = p.default;
+        }
+    }
+    const table = deepSubstitute(template.example_table, filled);
+    const root = deepSubstitute(template.example_root, filled);
+    const leftover = JSON.stringify({ table, root }).match(/\$\{(\w+)\}/);
+    if (leftover) {
+        return {
+            ok: false,
+            error: `Unresolved placeholder \${${leftover[1]}} — not declared in template parameters`,
+        };
+    }
+    return { ok: true, table, root };
+}
 export const GUARD_TEMPLATES_VERSION = "1.0.0";
 export const GUARD_TEMPLATES_COUNT = GUARD_TEMPLATES.length;

package/dist/knowledge/index.d.ts

@@ -1,5 +1,5 @@
 import { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields, type GlossaryEntry, type GlossaryCategory, type GlossaryDrift } from "./glossary.js";
-import { CONFIRMATION_RULES, SAFETY_RULES_VERSION, type ConfirmationRule, type OperationPreview, type ConfirmLevel } from "./safety-rules.js";
+import { CONFIRMATION_RULES, SAFETY_RULES_VERSION, OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, classifyTool, NAMING_CONVENTIONS, checkObjectReuseRules, checkImmutabilityRules, type ConfirmationRule, type OperationPreview, type ConfirmLevel, type ReuseRecommendation, type ObjectReuseRule, type ImmutabilityRule, type OperationClass, type OperationClassMeta, type SafetyRiskItem } from "./safety-rules.js";
 import { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, type ConstraintSeverity, type FieldConstraint, type OperationConstraint, type ConstraintViolation } from "./tool-constraints.js";
 import { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, type PermissionScope, type PermissionTypeDef, type GameElementType, type GameElementDef } from "./process-model.js";
 import { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, type ArbMetrics, type TrustScore, type TrustComponent } from "./arbitration-trust.js";
@@ -105,7 +105,7 @@ import { TOOLS_REFERENCE, getToolReference, searchToolReference, getToolSequence
 import { SCENARIO_MODES, SCENARIO_MODES_VERSION, MODE_COMPOSITIONS, matchScenarioMode, inferScenarioTraits, getScenarioMode, listScenarioModes, getShippedModes, getModeCompositions, type IndustryModeName, type ScenarioTraits, type ModeAllocatorStrategy, type ModeGuardRef, type ModeMachineNode, type ScenarioMode, type ModeComposition } from "./scenario-modes.js";
 import { GUARD_DESIGN_PATTERNS, GUARD_DESIGN_PATTERNS_VERSION, VERIFIER_LEVEL_GUIDANCE, getGuardDesignPattern, searchGuardDesignPatterns, getPatternsByHost, getPatternsByIndustry, getPatternsByDataSourceClass, getVerifierLevelGuidance, suggestPatternForRequirement, type GuardDataSourceClass, type VerifierConstraintLevel, type GuardHostObject, type GuardDesignPattern, type VerifierLevelGuidance } from "./guard-design-patterns.js";
 export { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields, type GlossaryEntry, type GlossaryCategory, type GlossaryDrift, };
-export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, type ConfirmationRule, type OperationPreview, type ConfirmLevel, };
+export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, classifyTool, NAMING_CONVENTIONS, checkObjectReuseRules, checkImmutabilityRules, type ConfirmationRule, type OperationPreview, type ConfirmLevel, type ReuseRecommendation, type ObjectReuseRule, type ImmutabilityRule, type OperationClass, type OperationClassMeta, type SafetyRiskItem, };
 export { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, type ConstraintSeverity, type FieldConstraint, type OperationConstraint, type ConstraintViolation, };
 export { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, type PermissionScope, type PermissionTypeDef, type GameElementType, type GameElementDef, };
 export { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, type ArbMetrics, type TrustScore, type TrustComponent, };

package/dist/knowledge/index.js

@@ -1,5 +1,5 @@
 import { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields } from "./glossary.js";
-import { CONFIRMATION_RULES, SAFETY_RULES_VERSION } from "./safety-rules.js";
+import { CONFIRMATION_RULES, SAFETY_RULES_VERSION, OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, classifyTool, NAMING_CONVENTIONS, checkObjectReuseRules, checkImmutabilityRules } from "./safety-rules.js";
 import { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, } from "./tool-constraints.js";
 import { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, } from "./process-model.js";
 import { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, } from "./arbitration-trust.js";
@@ -105,7 +105,7 @@ import { TOOLS_REFERENCE, getToolReference, searchToolReference, getToolSequence
 import { SCENARIO_MODES, SCENARIO_MODES_VERSION, MODE_COMPOSITIONS, matchScenarioMode, inferScenarioTraits, getScenarioMode, listScenarioModes, getShippedModes, getModeCompositions, } from "./scenario-modes.js";
 import { GUARD_DESIGN_PATTERNS, GUARD_DESIGN_PATTERNS_VERSION, VERIFIER_LEVEL_GUIDANCE, getGuardDesignPattern, searchGuardDesignPatterns, getPatternsByHost, getPatternsByIndustry, getPatternsByDataSourceClass, getVerifierLevelGuidance, suggestPatternForRequirement, } from "./guard-design-patterns.js";
 export { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields, };
-export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, };
+export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, classifyTool, NAMING_CONVENTIONS, checkObjectReuseRules, checkImmutabilityRules, };
 export { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, };
 export { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, };
 export { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, };

package/dist/knowledge/machine-ledger.js

@@ -284,7 +284,7 @@ export function inferSceneFromFlow(description) {
     if (lower.includes("wonder") || lower.includes("praise") || lower.includes("complain")
         || lower.includes("thumbs_up") || lower.includes("thumbs_down")
         || lower.includes("rating") || lower.includes("feedback")
-        || lower.includes("好评") || lower.includes("差评")) {
+        || lower.includes("praise") || lower.includes("complaint")) {
         return findScene("wonder_feedback");
     }
     if (lower.includes("reward") || lower.includes("incentive")) {

package/dist/knowledge/machine-render.d.ts

@@ -0,0 +1,41 @@
+export interface MachineNodeForRender {
+    name: string;
+    description?: string | null;
+}
+export interface MachineForwardForRender {
+    name: string;
+    weight: number;
+    named_operator?: string | null;
+    permission_index?: number | null;
+    guard?: string | null;
+    retained_submission?: number[] | string | null;
+}
+export interface MachineEdgeForRender {
+    from: string;
+    to: string;
+    threshold: number;
+    forwards: MachineForwardForRender[];
+}
+export interface MachineRenderInput {
+    nodes: MachineNodeForRender[];
+    edges: MachineEdgeForRender[];
+    machineName?: string | null;
+    machineAddress?: string | null;
+    published?: boolean | null;
+    paused?: boolean | null;
+}
+export declare function sanitizeMermaidNodeId(name: string): string;
+export declare function renderMachineMermaid(nodes: MachineNodeForRender[], edges: MachineEdgeForRender[], options?: {
+    colored?: boolean;
+}): string;
+export declare function renderMachineTreeIndented(input: MachineRenderInput): string;
+export declare function parseMachineTreeIndented(text: string): {
+    success: boolean;
+    data?: {
+        nodes: MachineNodeForRender[];
+        edges: MachineEdgeForRender[];
+    };
+    errors: string[];
+};
+export declare function renderMachineAscii(input: MachineRenderInput): string;
+export declare function renderMachineMarkmap(input: MachineRenderInput): string;