@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/evaluation/user-injection.js

@@ -0,0 +1,27 @@
+export const REQUIREMENT_PASS_THRESHOLD = 60;
+export function normalizeInjection(injection) {
+    return {
+        intent: injection?.intent,
+        preferences: injection?.preferences,
+        requirements: injection?.requirements ?? [],
+        overrides: injection?.overrides ?? {},
+    };
+}
+export function isRuleEnabled(ruleId, injection) {
+    const override = injection?.overrides?.rules?.[ruleId];
+    if (override && override.enabled !== undefined)
+        return override.enabled;
+    return true;
+}
+export function isDataSourceEnabled(dataSourceId, injection) {
+    const override = injection?.overrides?.data_sources?.[dataSourceId];
+    if (override && override.enabled !== undefined)
+        return override.enabled;
+    return true;
+}
+export function effectiveWeight(rule, injection) {
+    const override = injection?.overrides?.rules?.[rule.id];
+    if (override && override.weight !== undefined)
+        return override.weight;
+    return rule.weight;
+}

package/dist/examples/education-contact-create.json

@@ -0,0 +1,40 @@
+{
+  "title": "Create Education Contact Object",
+  "description": "Create a named Contact object for an education provider, with a Permission reference and an IM entry pointing at the support account",
+  "tags": ["contact", "messenger", "ims", "education"],
+  "industry": "education",
+  "operation_type": "contact",
+  "source": "Template-generated from K2 industry defaults (not chain-verified)",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "contact",
+    "data": {
+      "object": {
+        "name": "education_contact",
+        "permission": "education_permission",
+        "replaceExistName": true
+      },
+      "description": "Education provider contact — course info, attendance, and refund policy",
+      "ims": {
+        "op": "add",
+        "im": [
+          {
+            "at": "education_support",
+            "description": "Primary support account"
+          }
+        ]
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "Bind this Contact to the education Service via the service call's 'um' field.",
+    "Tuition should be escrowed and released per lesson (1/N) to prevent run-away disputes."
+  ]
+}

package/dist/examples/freelance-contact-create.json

@@ -0,0 +1,40 @@
+{
+  "title": "Create Freelance Contact Object",
+  "description": "Create a named Contact object for a freelance service provider, with a Permission reference and an IM entry pointing at the provider account",
+  "tags": ["contact", "messenger", "ims", "freelance"],
+  "industry": "freelance",
+  "operation_type": "contact",
+  "source": "Template-generated from K2 industry defaults (not chain-verified)",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "contact",
+    "data": {
+      "object": {
+        "name": "freelancer_contact",
+        "permission": "freelancer_permission",
+        "replaceExistName": true
+      },
+      "description": "Freelance provider contact — reach me for project requirements and delivery milestones",
+      "ims": {
+        "op": "add",
+        "im": [
+          {
+            "at": "freelancer",
+            "description": "Primary provider account"
+          }
+        ]
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "Bind this Contact to the freelance Service via the service call's 'um' field.",
+    "ims.im[].at accepts an account name or a full 0x address."
+  ]
+}

package/dist/examples/insurance-machine-create.json

@@ -4,7 +4,7 @@
   "tags": ["machine", "insurance", "claim", "workflow", "draft", "12-step"],
   "industry": "insurance",
   "operation_type": "machine",
-  "source": "docs/examples/Insurance — adapted to the 12-step plan (DRAFT only, schema-validated)",
+  "source": "docs/examples/Insurance — adapted to the 12-step plan (DRAFT only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/insurance-service-allocators.json

@@ -4,7 +4,7 @@
   "tags": ["service", "insurance", "order_allocators", "entity-sharing", "12-step"],
   "industry": "insurance",
   "operation_type": "service",
-  "source": "docs/examples/Insurance — adapted to the 12-step plan (allocators only, schema-validated)",
+  "source": "docs/examples/Insurance — adapted to the 12-step plan (allocators only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/machine-publish.json

@@ -4,7 +4,7 @@
   "tags": ["machine", "publish", "freeze", "immutable", "12-step"],
   "industry": "general",
   "operation_type": "machine",
-  "source": "12-step deploy plan (Step 6 Machine publish) — schema-validated",
+  "source": "12-step deploy plan (Step 6 Machine publish) — schema-validated, not chain-verified",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/rental-ziroom-service-create.json

@@ -4,7 +4,7 @@
   "tags": ["service", "rental", "draft", "create", "12-step"],
   "industry": "rental",
   "operation_type": "service",
-  "source": "ziroom testnet deployment 2026-07-29 — adapted to the 12-step plan (DRAFT only, schema-validated)",
+  "source": "ziroom testnet deployment 2026-07-29 — adapted to the 12-step plan (DRAFT only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/retail-adv-guard-messenger-proof-create.json

@@ -54,7 +54,7 @@
     }
   },
   "notes": [
-    "Strict-mode alternative to the broad 'Merkle Root length == 66' Guard (machine_merkle_root_v2). Broad mode trusts submitter honesty; strict mode enforces WHO submitted (谁得利谁举证 — whoever benefits bears the burden of proof) without verifying message content on-chain.",
+    "Strict-mode alternative to the broad 'Merkle Root length == 66' Guard (machine_merkle_root_v2). Broad mode trusts submitter honesty; strict mode enforces WHO submitted (whoever benefits bears the burden of proof) without verifying message content on-chain.",
     "Schema-verified: CallGuard_DataSchema (guard.ts) — namedNew creation form; table items carry no object_type (output-only); root logic_and returns Bool (allowed root type). logic_as_u256_greater compares first node > all subsequent nodes, so proof.time is listed before order.time.",
     "Query names verified against knowledge/guard-templates.ts (tpl that uses proof.signer/proof.time/order.time): proof.signer (Proof object, Address), proof.time (U64, clock-derived, always > 0), order.time (U64), order.service (Address). context enum is exactly 'Signer' | 'Clock' | 'Guard'.",
     "Proof generation (provider side, off-chain SDK): messenger submitChainProof(env, peerAddress, description) — about_address = the customer, order id embedded in description; returns proofAddress which is later submitted as identifier 0.",

package/dist/examples/retail-myshop-service-create.json

@@ -4,7 +4,7 @@
   "tags": ["service", "retail", "ecommerce", "draft", "create", "12-step"],
   "industry": "retail",
   "operation_type": "service",
-  "source": "myshop deployment walkthrough (docs/examples/MyShop) — adapted to the 12-step plan + testnet (DRAFT only, schema-validated)",
+  "source": "myshop deployment walkthrough (docs/examples/MyShop) — adapted to the 12-step plan + testnet (DRAFT only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/retail-myshop-service-customer-required.json

@@ -4,7 +4,7 @@
   "tags": ["service", "customer_required", "um", "contact", "messenger", "retail", "hard-linkage", "12-step"],
   "industry": "retail",
   "operation_type": "service",
-  "source": "adapted to the 12-step plan + SDK customer_required⟶um hard linkage (schema-validated)",
+  "source": "adapted to the 12-step plan + SDK customer_required⟶um hard linkage (schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/subscription-contact-create.json

@@ -0,0 +1,40 @@
+{
+  "title": "Create Subscription Contact Object",
+  "description": "Create a named Contact object for a subscription service, with a Permission reference and an IM entry pointing at the support account",
+  "tags": ["contact", "messenger", "ims", "subscription"],
+  "industry": "subscription",
+  "operation_type": "contact",
+  "source": "Template-generated from K2 industry defaults (not chain-verified)",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "contact",
+    "data": {
+      "object": {
+        "name": "subscription_contact",
+        "permission": "subscription_permission",
+        "replaceExistName": true
+      },
+      "description": "Subscription support contact — manage your plan, pause, or cancel anytime",
+      "ims": {
+        "op": "add",
+        "im": [
+          {
+            "at": "subscription_support",
+            "description": "Primary support account"
+          }
+        ]
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "Bind this Contact to the subscription Service via the service call's 'um' field.",
+    "Subscription billing should use charge_guard_signer (explicit user signature per period)."
+  ]
+}

package/dist/examples/threebody-machine-create.json

@@ -4,7 +4,7 @@
   "tags": ["machine", "multisig", "signature", "approval-gate", "permissionIndex", "draft", "12-step"],
   "industry": "general",
   "operation_type": "machine",
-  "source": "docs/examples/ThreeBody_Signature — adapted to the 12-step plan (DRAFT only, schema-validated)",
+  "source": "docs/examples/ThreeBody_Signature — adapted to the 12-step plan (DRAFT only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/travel-machine-create.json

@@ -4,7 +4,7 @@
   "tags": ["machine", "travel", "workflow", "forward-guard", "multi-node", "draft", "12-step"],
   "industry": "travel",
   "operation_type": "machine",
-  "source": "docs/examples/Travel — adapted to the 12-step plan (DRAFT only, schema-validated)",
+  "source": "docs/examples/Travel — adapted to the 12-step plan (DRAFT only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/examples/travel-service-create.json

@@ -4,7 +4,7 @@
   "tags": ["service", "travel", "draft", "create", "12-step"],
   "industry": "travel",
   "operation_type": "service",
-  "source": "docs/examples/Travel — adapted to the 12-step plan (DRAFT only, schema-validated)",
+  "source": "docs/examples/Travel — adapted to the 12-step plan (DRAFT only, schema-validated, not chain-verified)",
   "verified": false,
   "network": "testnet",
   "call": {

package/dist/harness/plan.js

@@ -42,8 +42,8 @@ export const SCENARIO_REGISTRY = [
         ],
     },
     {
-        name: "digital_goods",
-        keywords: ["digital", "download", "ebook", "software", "license", "instant", "content"],
+        name: "retail",
+        keywords: ["retail", "shop", "store", "ecommerce", "buy", "sell", "product", "digital", "download", "ebook", "software", "license", "instant", "content"],
         description: "Instant digital delivery: publish → buy → instant delivery",
         default_permissions: { provider: 1000, customer: "namedOperator" },
         objects: [
@@ -60,7 +60,7 @@ export const SCENARIO_REGISTRY = [
         ],
     },
     {
-        name: "travel_package",
+        name: "travel",
         keywords: ["travel", "tour", "trip", "package", "booking", "itinerary", "vacation", "hotel"],
         description: "Multi-stage service with milestones: publish → book → itinerary → complete",
         default_permissions: { provider: 1000, customer: "namedOperator", arbiter: 1500 },
@@ -79,6 +79,45 @@ export const SCENARIO_REGISTRY = [
             { name: "Publish", object_types: ["Service"] },
         ],
     },
+    {
+        name: "education",
+        keywords: ["education", "course", "training", "tutor", "teach", "learn", "school", "coach", "class", "lesson"],
+        description: "Long-cycle education with milestones: publish → enroll → teach → complete → certificate",
+        default_permissions: { provider: 1000, customer: "namedOperator", arbiter: 1500 },
+        objects: [
+            { type: "Permission", reversible: true, dependencies: [], user_decisions: ["reuse existing or create new?"], estimated_time: "2min" },
+            { type: "Service", reversible: true, dependencies: ["Permission"], user_decisions: ["name", "course details", "token_type"], estimated_time: "3min" },
+            { type: "Machine", reversible: true, dependencies: ["Service"], user_decisions: ["enrollment states", "milestone flow", "completion"], estimated_time: "15min" },
+            { type: "Guard", reversible: false, dependencies: ["Machine"], user_decisions: ["enrollment guard", "completion guard"], risk_flags: ["immutable_after_creation"], estimated_time: "5min" },
+            { type: "Guard", reversible: false, dependencies: ["Machine"], user_decisions: ["refund guard"], risk_flags: ["immutable_after_creation"], estimated_time: "5min" },
+            { type: "Allocation", reversible: true, dependencies: ["Service", "Guard"], user_decisions: ["milestone payments", "refund policy"], estimated_time: "5min" },
+        ],
+        phases: [
+            { name: "Foundation", object_types: ["Permission", "Service"] },
+            { name: "Business Logic", object_types: ["Machine"] },
+            { name: "Trust Layer", object_types: ["Guard"] },
+            { name: "Revenue", object_types: ["Allocation"] },
+            { name: "Publish", object_types: ["Service"] },
+        ],
+    },
+    {
+        name: "subscription",
+        keywords: ["subscription", "subscribe", "membership", "recurring", "monthly", "newsletter", "patreon", "tier"],
+        description: "Recurring subscription with renewal: publish → subscribe → renew → cancel",
+        default_permissions: { provider: 1000, customer: "namedOperator" },
+        objects: [
+            { type: "Permission", reversible: true, dependencies: [], estimated_time: "2min" },
+            { type: "Service", reversible: true, dependencies: ["Permission"], user_decisions: ["name", "subscription tiers", "token_type"], estimated_time: "3min" },
+            { type: "Machine", reversible: true, dependencies: ["Service"], user_decisions: ["subscribe states", "renewal flow", "cancellation"], estimated_time: "10min" },
+            { type: "Allocation", reversible: true, dependencies: ["Service"], user_decisions: ["revenue split"], estimated_time: "3min" },
+        ],
+        phases: [
+            { name: "Foundation", object_types: ["Permission", "Service"] },
+            { name: "Business Logic", object_types: ["Machine"] },
+            { name: "Revenue", object_types: ["Allocation"] },
+            { name: "Publish", object_types: ["Service"] },
+        ],
+    },
     {
         name: "general",
         keywords: [],

package/dist/intent/enrich.d.ts

@@ -0,0 +1 @@
+export declare function enrichEventsWithObjectText(events: Record<string, unknown>[], network?: string): Promise<Record<string, unknown>[]>;

package/dist/intent/enrich.js

@@ -0,0 +1,67 @@
+import { query_objects } from "@wowok/wowok";
+const OBJECT_FIELDS = [
+    "service",
+    "demand",
+    "order",
+    "progress",
+    "arb",
+    "arbitration",
+    "machine",
+    "allocation",
+];
+const TEXT_FIELDS = ["recommend", "feedback", "node", "description"];
+const MAX_OBJECTS_PER_QUERY = 50;
+function hasText(event) {
+    return TEXT_FIELDS.some((k) => {
+        const v = event[k];
+        return typeof v === "string" && v.length > 0;
+    });
+}
+export async function enrichEventsWithObjectText(events, network) {
+    const ids = new Set();
+    for (const ev of events) {
+        if (hasText(ev))
+            continue;
+        for (const k of OBJECT_FIELDS) {
+            const v = ev[k];
+            if (typeof v === "string" && v.startsWith("0x"))
+                ids.add(v);
+        }
+    }
+    if (ids.size === 0)
+        return events;
+    const descById = new Map();
+    const idList = Array.from(ids);
+    for (let i = 0; i < idList.length; i += MAX_OBJECTS_PER_QUERY) {
+        const batch = idList.slice(i, i + MAX_OBJECTS_PER_QUERY);
+        try {
+            const res = await query_objects({ objects: batch, no_cache: false, network });
+            const objects = res?.objects ?? [];
+            for (const obj of objects) {
+                const id = obj?.object;
+                const desc = obj?.description;
+                if (typeof id === "string" && typeof desc === "string" && desc) {
+                    descById.set(id, desc);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    if (descById.size === 0)
+        return events;
+    return events.map((ev) => {
+        if (hasText(ev))
+            return ev;
+        for (const k of OBJECT_FIELDS) {
+            const v = ev[k];
+            if (typeof v === "string") {
+                const desc = descById.get(v);
+                if (desc) {
+                    return { ...ev, _enriched_description: desc, description: desc };
+                }
+            }
+        }
+        return ev;
+    });
+}

package/dist/intent/index.d.ts

@@ -0,0 +1,23 @@
+import type { IntentMatchResult, IntentRecord, IntentTargetType } from "./types.js";
+import { ALL_INTENT_TARGET_TYPES } from "./types.js";
+import type { IndustryScenario } from "../evaluation/capability.js";
+import type { PersonaRole } from "../persona/types.js";
+export { newIntentId, getIntentStore, setIntentStore, SqliteIntentRadarStore, type IntentRadarStore } from "./store.js";
+export { matchEventsToIntents } from "./matcher.js";
+export { ALL_INTENT_TARGET_TYPES, INTENT_MAX_PER_SCOPE, type IntentRecord, type IntentTargetType, type IntentMatchResult, type IntentEventHit } from "./types.js";
+export declare function resolveIntentSignals(intentText: string): {
+    industries: IndustryScenario[];
+    keywords: string[];
+};
+export interface CreateIntentInput {
+    intent: string;
+    account?: string;
+    role?: PersonaRole;
+    target_types?: IntentTargetType[];
+}
+export declare function createIntent(input: CreateIntentInput): Promise<IntentRecord>;
+export declare function listIntents(account?: string): Promise<IntentRecord[]>;
+export declare function removeIntent(id: string): Promise<boolean>;
+export declare function matchIntent(intentId: string, events: Record<string, unknown>[]): Promise<IntentMatchResult | null>;
+export declare function matchAllIntents(events: Record<string, unknown>[], account?: string): Promise<IntentMatchResult[]>;
+export { ALL_INTENT_TARGET_TYPES as SUPPORTED_TARGET_TYPES };

package/dist/intent/index.js

@@ -0,0 +1,60 @@
+import { findSimilarIndustries, inferTraitsFromDescription } from "../knowledge/industry-generalizer.js";
+import { matchEventsToIntents } from "./matcher.js";
+import { getIntentStore, newIntentId } from "./store.js";
+import { ALL_INTENT_TARGET_TYPES, INTENT_MAX_PER_SCOPE } from "./types.js";
+export { newIntentId, getIntentStore, setIntentStore, SqliteIntentRadarStore } from "./store.js";
+export { matchEventsToIntents } from "./matcher.js";
+export { ALL_INTENT_TARGET_TYPES, INTENT_MAX_PER_SCOPE } from "./types.js";
+export function resolveIntentSignals(intentText) {
+    const text = intentText?.trim();
+    if (!text)
+        return { industries: [], keywords: [] };
+    const { traits, matched_keywords } = inferTraitsFromDescription(text);
+    if (matched_keywords.length === 0)
+        return { industries: [], keywords: [] };
+    const similar = findSimilarIndustries(traits, 3);
+    const industries = similar
+        .slice(0, 3)
+        .map((s) => s.industry)
+        .filter((i) => i && i !== "general");
+    return { industries, keywords: matched_keywords };
+}
+export async function createIntent(input) {
+    const signals = resolveIntentSignals(input.intent);
+    const store = getIntentStore();
+    const existing = await store.list(input.account);
+    if (existing.length >= INTENT_MAX_PER_SCOPE) {
+        throw new Error(`intent limit reached (${INTENT_MAX_PER_SCOPE}) for scope ${input.account ?? "system"}`);
+    }
+    const now = Date.now();
+    const record = {
+        id: newIntentId(),
+        intent: input.intent,
+        account: input.account,
+        role: input.role,
+        industries: signals.industries,
+        keywords: signals.keywords,
+        target_types: input.target_types ?? [],
+        created_at: now,
+        updated_at: now,
+    };
+    await store.save(record);
+    return record;
+}
+export async function listIntents(account) {
+    return getIntentStore().list(account);
+}
+export async function removeIntent(id) {
+    return getIntentStore().remove(id);
+}
+export async function matchIntent(intentId, events) {
+    const intent = await getIntentStore().get(intentId);
+    if (!intent)
+        return null;
+    return matchEventsToIntents(events, [intent])[0];
+}
+export async function matchAllIntents(events, account) {
+    const intents = await getIntentStore().list(account);
+    return matchEventsToIntents(events, intents);
+}
+export { ALL_INTENT_TARGET_TYPES as SUPPORTED_TARGET_TYPES };

package/dist/intent/matcher.d.ts

@@ -0,0 +1,2 @@
+import type { IntentMatchResult, IntentRecord } from "./types.js";
+export declare function matchEventsToIntents(events: Record<string, unknown>[], intents: IntentRecord[]): IntentMatchResult[];

package/dist/intent/matcher.js

@@ -0,0 +1,81 @@
+import { findSimilarIndustries, inferTraitsFromDescription } from "../knowledge/industry-generalizer.js";
+const TEXT_FIELDS = ["recommend", "feedback", "node", "description"];
+const OBJECT_FIELDS = [
+    "order", "service", "demand", "progress", "arb", "arbitration",
+    "allocation", "discount", "machine", "task", "address", "resource",
+];
+function eventText(event) {
+    return TEXT_FIELDS
+        .map((k) => event[k])
+        .filter((v) => typeof v === "string" && v.length > 0)
+        .join(" ");
+}
+function eventSignals(event) {
+    const text = eventText(event);
+    if (!text)
+        return { industries: [], keywords: [] };
+    const { traits, matched_keywords } = inferTraitsFromDescription(text);
+    if (matched_keywords.length === 0)
+        return { industries: [], keywords: [] };
+    const similar = findSimilarIndustries(traits, 3);
+    return {
+        industries: similar.slice(0, 3).map((s) => s.industry),
+        keywords: matched_keywords,
+    };
+}
+function eventId(event) {
+    const id = event.id;
+    if (id?.txDigest)
+        return `${id.eventSeq ?? ""}:${id.txDigest}`;
+    return String(event.id ?? "");
+}
+function relatedObjects(event) {
+    const out = new Set();
+    for (const k of OBJECT_FIELDS) {
+        const v = event[k];
+        if (typeof v === "string" && v.startsWith("0x"))
+            out.add(v);
+    }
+    return Array.from(out);
+}
+function eventType(event) {
+    return String(event.type ?? event.type_raw ?? "");
+}
+function scoreEvent(event, intent) {
+    const sig = eventSignals(event);
+    const matchedIndustries = intent.industries.filter((i) => i !== "general" && sig.industries.includes(i));
+    const matchedKeywords = intent.keywords.filter((k) => sig.keywords.includes(k));
+    const score = Math.min(100, matchedIndustries.length * 40 + matchedKeywords.length * 20);
+    if (score === 0)
+        return null;
+    return {
+        event_type: eventType(event),
+        event_id: eventId(event),
+        related_objects: relatedObjects(event),
+        business_meaning: eventType(event),
+        score,
+        matched_industries: matchedIndustries,
+        matched_keywords: matchedKeywords,
+        event,
+    };
+}
+export function matchEventsToIntents(events, intents) {
+    return intents.map((intent) => {
+        const hits = [];
+        for (const event of events) {
+            const type = eventType(event);
+            if (intent.target_types.length > 0 && !intent.target_types.includes(type))
+                continue;
+            const hit = scoreEvent(event, intent);
+            if (hit)
+                hits.push(hit);
+        }
+        hits.sort((a, b) => b.score - a.score);
+        return {
+            intent_id: intent.id,
+            intent: intent.intent,
+            hits,
+            scanned: events.length,
+        };
+    });
+}

package/dist/intent/store.d.ts

@@ -0,0 +1,19 @@
+import { SQLiteStorage } from "@wowok/wowok";
+import type { IntentRecord } from "./types.js";
+export interface IntentRadarStore {
+    save(record: IntentRecord): Promise<void>;
+    get(id: string): Promise<IntentRecord | null>;
+    list(account?: string): Promise<IntentRecord[]>;
+    remove(id: string): Promise<boolean>;
+}
+export declare function newIntentId(): string;
+export declare class SqliteIntentRadarStore implements IntentRadarStore {
+    private readonly kv;
+    constructor(kv?: SQLiteStorage);
+    save(record: IntentRecord): Promise<void>;
+    get(id: string): Promise<IntentRecord | null>;
+    list(account?: string): Promise<IntentRecord[]>;
+    remove(id: string): Promise<boolean>;
+}
+export declare function getIntentStore(): IntentRadarStore;
+export declare function setIntentStore(store: IntentRadarStore): void;

package/dist/intent/store.js

@@ -0,0 +1,55 @@
+import { SQLiteStorage } from "@wowok/wowok";
+const KEY_PREFIX = "intent_radar:";
+function parse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function newIntentId() {
+    return `ir_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+export class SqliteIntentRadarStore {
+    kv;
+    constructor(kv) {
+        this.kv = kv ?? new SQLiteStorage();
+    }
+    async save(record) {
+        await this.kv.put(`${KEY_PREFIX}${record.id}`, JSON.stringify(record));
+    }
+    async get(id) {
+        const raw = await this.kv.get(`${KEY_PREFIX}${id}`);
+        return raw ? parse(raw) : null;
+    }
+    async list(account) {
+        const rows = await this.kv.list(KEY_PREFIX);
+        const out = [];
+        for (const { value } of rows) {
+            const record = parse(value);
+            if (!record)
+                continue;
+            if (account === undefined || record.account === account) {
+                out.push(record);
+            }
+        }
+        return out.sort((a, b) => b.updated_at - a.updated_at);
+    }
+    async remove(id) {
+        const key = `${KEY_PREFIX}${id}`;
+        const exists = (await this.kv.get(key)) !== undefined;
+        if (exists)
+            await this.kv.del(key);
+        return exists;
+    }
+}
+let _store = null;
+export function getIntentStore() {
+    if (!_store)
+        _store = new SqliteIntentRadarStore();
+    return _store;
+}
+export function setIntentStore(store) {
+    _store = store;
+}