@wowok/agent-mcp 2.6.1 → 2.6.3

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/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;