@kanvas/openclaw-plugin 0.1.16 → 0.1.17

package/dist/domains/deals/index.js

@@ -0,0 +1,103 @@
+export class DealsService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async listDeals(first = 25, search, where) {
+        const query = `
+      query ListDeals($first: Int, $search: String, $where: QueryDealsWhereWhereConditions) {
+        deals(first: $first, search: $search, where: $where) {
+          data {
+            id
+            uuid
+            title
+            description
+            created_at
+            updated_at
+            owner { id uuid displayname }
+            lead { id uuid }
+            people { id uuid firstname lastname }
+            organization { id name }
+            pipeline { id name }
+            stage { id name }
+            status { id name }
+          }
+          paginatorInfo {
+            currentPage
+            lastPage
+            total
+          }
+        }
+      }
+    `;
+        return this.client.query(query, { first, search, where });
+    }
+    async getDeal(id) {
+        const query = `
+      query GetDeal($id: ID!) {
+        deal(id: $id) {
+          id
+          uuid
+          title
+          description
+          created_at
+          updated_at
+          owner { id uuid displayname }
+          lead { id uuid }
+          people { id uuid firstname lastname }
+          organization { id name }
+          pipeline { id name }
+          stage { id name }
+          status { id name }
+          tags { id name }
+          custom_fields { name value }
+        }
+      }
+    `;
+        return this.client.query(query, { id });
+    }
+    async createDeal(input) {
+        const mutation = `
+      mutation CreateDeal($input: DealInput!) {
+        createDeal(input: $input) {
+          id
+          uuid
+          title
+          description
+          created_at
+          owner { id uuid displayname }
+          pipeline { id name }
+          stage { id name }
+          status { id name }
+        }
+      }
+    `;
+        return this.client.query(mutation, { input });
+    }
+    async updateDeal(id, input) {
+        const mutation = `
+      mutation UpdateDeal($id: ID!, $input: UpdateDealInput!) {
+        updateDeal(id: $id, input: $input) {
+          id
+          uuid
+          title
+          description
+          updated_at
+          owner { id uuid displayname }
+          pipeline { id name }
+          stage { id name }
+          status { id name }
+        }
+      }
+    `;
+        return this.client.query(mutation, { id, input });
+    }
+    async deleteDeal(id) {
+        const mutation = `
+      mutation DeleteDeal($id: ID!) {
+        deleteDeal(id: $id)
+      }
+    `;
+        return this.client.query(mutation, { id });
+    }
+}

package/dist/domains/deals/types.js

@@ -0,0 +1 @@
+export {};

package/dist/domains/events/index.js

@@ -0,0 +1,157 @@
+export class EventsService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async listEvents(first = 25, search, where) {
+        const query = `
+      query ListEvents($first: Int, $search: String, $where: QueryEventsWhereWhereConditions) {
+        events(first: $first, search: $search, where: $where) {
+          data {
+            id
+            uuid
+            name
+            slug
+            description
+            created_at
+            updated_at
+            type { id name }
+            eventStatus { id name }
+            category { id name }
+            versions {
+              data {
+                id
+                start_at
+                end_at
+                dates {
+                  id
+                  date
+                  start_time
+                  end_time
+                }
+              }
+            }
+          }
+          paginatorInfo {
+            currentPage
+            lastPage
+            total
+          }
+        }
+      }
+    `;
+        return this.client.query(query, { first, search, where });
+    }
+    async getEvent(id) {
+        const query = `
+      query GetEvent($where: QueryEventsWhereWhereConditions) {
+        events(first: 1, where: $where) {
+          data {
+            id
+            uuid
+            name
+            slug
+            description
+            created_at
+            updated_at
+            type { id name }
+            eventStatus { id name }
+            category { id name }
+            resources_id
+            resources_type
+            versions {
+              data {
+                id
+                version
+                start_at
+                end_at
+                max_capacity
+                dates {
+                  id
+                  date
+                  start_time
+                  end_time
+                }
+              }
+            }
+            tags { id name }
+            custom_fields { name value }
+          }
+        }
+      }
+    `;
+        return this.client.query(query, {
+            where: { column: "ID", operator: "EQ", value: id },
+        });
+    }
+    async createEvent(input) {
+        const mutation = `
+      mutation CreateEvent($input: EventInput!) {
+        createEvent(input: $input) {
+          id
+          uuid
+          name
+          slug
+          description
+          created_at
+          type { id name }
+          eventStatus { id name }
+          versions {
+            data {
+              id
+              start_at
+              end_at
+              dates {
+                id
+                date
+                start_time
+                end_time
+              }
+            }
+          }
+        }
+      }
+    `;
+        return this.client.query(mutation, { input });
+    }
+    async updateEvent(id, input) {
+        const mutation = `
+      mutation UpdateEvent($id: ID!, $input: EventUpdateInput!) {
+        updateEvent(id: $id, input: $input) {
+          id
+          uuid
+          name
+          description
+          updated_at
+          type { id name }
+          eventStatus { id name }
+        }
+      }
+    `;
+        return this.client.query(mutation, { id, input });
+    }
+    async deleteEvent(id) {
+        const mutation = `
+      mutation DeleteEvent($id: ID!) {
+        deleteEvent(id: $id)
+      }
+    `;
+        return this.client.query(mutation, { id });
+    }
+    async followEvent(input) {
+        const mutation = `
+      mutation FollowEvent($input: FollowInput!) {
+        followEvent(input: $input)
+      }
+    `;
+        return this.client.query(mutation, { input });
+    }
+    async unFollowEvent(input) {
+        const mutation = `
+      mutation UnFollowEvent($input: FollowInput!) {
+        unFollowEvent(input: $input)
+      }
+    `;
+        return this.client.query(mutation, { input });
+    }
+}

package/dist/domains/events/types.js

@@ -0,0 +1 @@
+export {};

package/dist/domains/orders/index.js

@@ -3,6 +3,7 @@ export class OrdersService {
     constructor(client) {
         this.client = client;
     }
+    // ── Read ───────────────────────────────────────────────────
     async searchOrders(search, first = 10) {
         const query = `
       query SearchOrders($first: Int!, $search: String) {
@@ -54,4 +55,148 @@ export class OrdersService {
             where: { column: "ID", operator: "EQ", value: id },
         });
     }
+    // ── Lookups ────────────────────────────────────────────────
+    async listOrderStatuses(first = 50) {
+        const query = `
+      query ListOrderStatuses($first: Int) {
+        orderStatuses(first: $first) {
+          data {
+            id
+            name
+            slug
+            is_default
+            is_final
+            sequence
+            order_type_id
+          }
+        }
+      }
+    `;
+        return this.client.query(query, { first });
+    }
+    async listOrderTypes(first = 50) {
+        const query = `
+      query ListOrderTypes($first: Int) {
+        orderTypes(first: $first) {
+          data {
+            id
+            name
+            slug
+            title
+            total_statuses
+          }
+        }
+      }
+    `;
+        return this.client.query(query, { first });
+    }
+    async listRegions(first = 50) {
+        const query = `
+      query ListRegions($first: Int) {
+        regions(first: $first) {
+          data {
+            id
+            uuid
+            name
+            slug
+            currency
+            is_default
+          }
+        }
+      }
+    `;
+        return this.client.query(query, { first });
+    }
+    // ── Write ──────────────────────────────────────────────────
+    async createDraftOrder(input) {
+        const mutation = `
+      mutation CreateDraftOrder($input: DraftOrderInput!) {
+        createDraftOrder(input: $input) {
+          id
+          uuid
+          order_number
+          status
+          total_gross_amount
+          total_net_amount
+          created_at
+        }
+      }
+    `;
+        return this.client.query(mutation, { input });
+    }
+    async updateOrder(id, input) {
+        const mutation = `
+      mutation UpdateOrder($id: ID!, $input: UpdateOrderInput!) {
+        updateOrder(id: $id, input: $input) {
+          order {
+            id
+            uuid
+            order_number
+            status
+            fulfillment_status
+            payment_status
+            total_gross_amount
+          }
+          message
+        }
+      }
+    `;
+        return this.client.query(mutation, { id, input });
+    }
+    async updateDraftOrderStatus(orderId, status) {
+        const mutation = `
+      mutation UpdateDraftOrderStatus($order_id: ID!, $status: OrderStatusEnum!) {
+        updateDraftOrderStatus(order_id: $order_id, status: $status) {
+          id
+          uuid
+          order_number
+          status
+        }
+      }
+    `;
+        return this.client.query(mutation, { order_id: orderId, status });
+    }
+    async transitionOrderStatus(orderId, statusSlug, date) {
+        const mutation = `
+      mutation TransitionOrderStatus($input: TransitionOrderStatusInput!) {
+        transitionOrderStatus(input: $input) {
+          status
+          message
+        }
+      }
+    `;
+        return this.client.query(mutation, {
+            input: { order_id: orderId, status_slug: statusSlug, date },
+        });
+    }
+    async changeOrderCustomer(orderId, customerId) {
+        const mutation = `
+      mutation OrderChangeCustomer($order_id: ID!, $customer_id: ID!) {
+        orderChangeCustomer(order_id: $order_id, customer_id: $customer_id)
+      }
+    `;
+        return this.client.queryWithAppKey(mutation, {
+            order_id: orderId,
+            customer_id: customerId,
+        });
+    }
+    async deleteOrder(id) {
+        const mutation = `
+      mutation DeleteOrder($id: ID!) {
+        deleteOrder(id: $id)
+      }
+    `;
+        return this.client.query(mutation, { id });
+    }
+    async sendOrderEmail(orderId, template) {
+        const mutation = `
+      mutation SendOrderEmail($order_id: ID!, $template: String) {
+        sendOrderEmail(order_id: $order_id, template: $template)
+      }
+    `;
+        return this.client.queryWithAppKey(mutation, {
+            order_id: orderId,
+            template,
+        });
+    }
 }

package/dist/domains/orders/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -5,11 +5,15 @@ import { InventoryService } from "./domains/inventory/index.js";
 import { OrdersService } from "./domains/orders/index.js";
 import { SocialService } from "./domains/social/index.js";
 import { EcosystemService } from "./domains/ecosystem/index.js";
+import { DealsService } from "./domains/deals/index.js";
+import { EventsService } from "./domains/events/index.js";
 import { registerCrmTools } from "./tools/crm.js";
 import { registerInventoryTools } from "./tools/inventory.js";
 import { registerOrdersTools } from "./tools/orders.js";
 import { registerSocialTools } from "./tools/social.js";
 import { registerEcosystemTools } from "./tools/ecosystem.js";
+import { registerDealsTools } from "./tools/deals.js";
+import { registerEventsTools } from "./tools/events.js";
 import { toolResult } from "./tools/helpers.js";
 const DEFAULT_API_URL = "https://graphapi.kanvas.dev/graphql";
 // OpenClaw v2026.4.5+ calls register() per-agent-context (main, subagents,
@@ -23,6 +27,8 @@ let sharedInventory = null;
 let sharedOrders = null;
 let sharedSocial = null;
 let sharedEcosystem = null;
+let sharedDeals = null;
+let sharedEvents = null;
 let startupBannerShown = false;
 let skipBannerShown = false;
 function resolveConfig(pluginConfig) {
@@ -115,6 +121,8 @@ export default {
             sharedOrders = new OrdersService(sharedClient);
             sharedSocial = new SocialService(sharedClient);
             sharedEcosystem = new EcosystemService(sharedClient);
+            sharedDeals = new DealsService(sharedClient);
+            sharedEvents = new EventsService(sharedClient);
         }
         // Tools and hooks must be registered on every api object — each one is
         // a separate agent context (main, subagents, cron lanes).
@@ -124,6 +132,8 @@ export default {
         registerOrdersTools(api, sharedOrders, ensureAuth);
         registerSocialTools(api, sharedSocial, ensureAuth);
         registerEcosystemTools(api, sharedEcosystem, ensureAuth);
+        registerDealsTools(api, sharedDeals, ensureAuth);
+        registerEventsTools(api, sharedEvents, ensureAuth);
         api.registerTool({
             name: "kanvas_test_connection",
             label: "Test Connection",
@@ -148,7 +158,7 @@ export default {
         }, { commands: ["setup"] });
         if (!startupBannerShown) {
             startupBannerShown = true;
-            api.logger.info("Kanvas plugin registered — 53 tools loaded");
+            api.logger.info("Kanvas plugin registered — 73 tools loaded");
         }
     },
 };
@@ -222,6 +232,16 @@ Use when the user asks about products, stock, warehouses, or catalog.
 Use when the user asks about orders, purchases, or sales.
 - \`kanvas_search_orders\` → find orders by number or keyword
 - \`kanvas_get_order\` → full order detail with items, customer, status
+- \`kanvas_list_order_statuses\` → get status slugs for transitions
+- \`kanvas_list_order_types\` → order type pipelines (standard, subscription, etc.)
+- \`kanvas_list_regions\` → regions for order creation (get region_id)
+- \`kanvas_create_draft_order\` → create a draft order. Requires email, customer, region_id (from kanvas_list_regions), and items with variant_id+quantity (from kanvas_list_variants)
+- \`kanvas_update_order\` → update items, status, metadata
+- \`kanvas_update_draft_order_status\` → change draft order status (PENDING, COMPLETED, DRAFT, CANCELED, FAILED)
+- \`kanvas_transition_order_status\` → move through the order status pipeline (use status_slug from kanvas_list_order_statuses)
+- \`kanvas_order_change_customer\` → change the customer on an order (requires xKanvasKey)
+- \`kanvas_delete_order\` → delete an order
+- \`kanvas_send_order_email\` → send a confirmation/receipt email (requires xKanvasKey)
 
 **Follow-ups & Reminders**
 ALWAYS schedule follow-ups in Kanvas so the human team can see them — NEVER store them only in local memory.
@@ -229,6 +249,23 @@ ALWAYS schedule follow-ups in Kanvas so the human team can see them — NEVER st
 - \`kanvas_list_events\` → list scheduled events/follow-ups
 - For structured follow-up data (tracking status, priority, custom fields), use \`kanvas_create_message\` with verb "follow_up" and a JSON payload containing { due_date, lead_id, action, status, priority }.
 
+**Deals (Sales Opportunities)**
+Use when the user asks about deals, opportunities, sales tracking. A deal is a potential sale, often tied to a lead/person/organization and moved through a pipeline.
+- \`kanvas_list_deals\` → list/search deals with owner, pipeline, stage, status
+- \`kanvas_get_deal\` → full deal detail including tags and custom fields
+- \`kanvas_create_deal\` → create a deal (only title required; optionally link to lead, person, org, pipeline, owner)
+- \`kanvas_update_deal\` → update title, description, pipeline stage, owner, linked entities
+- \`kanvas_delete_deal\` → delete a deal
+
+**Events (Full event management)**
+For simple follow-ups linked to a lead, prefer \`kanvas_create_follow_up\`. Use these when the user wants richer event management (categories, types, resources, tags).
+- \`kanvas_list_events_full\` → list events with versions and dates
+- \`kanvas_get_event\` → event detail including versions, tags, custom fields
+- \`kanvas_create_event\` → create an event with one or more dates. Supports linking to resources (leads, deals), categories, types, tags.
+- \`kanvas_update_event\` → update name, description, dates, status
+- \`kanvas_delete_event\` → delete an event
+- \`kanvas_follow_event\` / \`kanvas_unfollow_event\` → subscribe/unsubscribe user to event updates
+
 **Ecosystem (Companies, Branches, Roles, Users)**
 Use when the user asks about companies, branches/locations, user management, roles, or permissions.
 - \`kanvas_list_companies\` → list/search companies

package/dist/tools/deals.js

@@ -0,0 +1,91 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+const WhereClause = Type.Optional(Type.Array(Type.Object({
+    column: Type.String(),
+    operator: Type.String({ description: 'e.g. "EQ", "LIKE"' }),
+    value: Type.Unknown(),
+}), { description: "Filter conditions" }));
+export function registerDealsTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_list_deals",
+        label: "List Deals",
+        description: "List or search deals. A deal represents a potential sale/opportunity linked to a lead, person, or organization.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 25)" })),
+            search: Type.Optional(Type.String({ description: "Search keyword" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listDeals(params.first, params.search, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_deal",
+        label: "Get Deal",
+        description: "Get full details for a deal by ID, including pipeline stage, owner, linked lead/person/org, tags, and custom fields.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Deal ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getDeal(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_create_deal",
+        label: "Create Deal",
+        description: "Create a deal. Only title is required. Optionally link to a lead, person, organization, or pipeline stage.",
+        parameters: Type.Object({
+            title: Type.String({ description: "Deal title" }),
+            description: Type.Optional(Type.String()),
+            leads_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Linked lead ID" })),
+            people_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Linked person ID" })),
+            organization_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Deal owner user ID" })),
+            pipeline_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            pipeline_stage_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Number()),
+            companies_branches_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createDeal(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_deal",
+        label: "Update Deal",
+        description: "Update a deal's title, description, pipeline stage, owner, or linked entities.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Deal ID" }),
+            title: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            leads_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            people_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            organization_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            pipeline_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            pipeline_stage_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Number()),
+            companies_branches_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updateDeal(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_deal",
+        label: "Delete Deal",
+        description: "Delete a deal by ID.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Deal ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteDeal(params.id));
+        },
+    });
+}

package/dist/tools/events.js

@@ -0,0 +1,134 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+const WhereClause = Type.Optional(Type.Array(Type.Object({
+    column: Type.String(),
+    operator: Type.String({ description: 'e.g. "EQ", "LIKE"' }),
+    value: Type.Unknown(),
+}), { description: "Filter conditions" }));
+const EventDateInput = Type.Object({
+    date: Type.String({ description: "YYYY-MM-DD" }),
+    start_time: Type.String({ description: "HH:MM (24h)" }),
+    end_time: Type.String({ description: "HH:MM (24h)" }),
+});
+const EventResourceInput = Type.Object({
+    resources_id: Type.String({ description: "Entity ID this event is attached to" }),
+    resources_type: Type.String({ description: 'e.g. "lead", "deal"' }),
+});
+const TagInput = Type.Object({
+    name: Type.String(),
+    slug: Type.Optional(Type.String()),
+});
+export function registerEventsTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_list_events_full",
+        label: "List Events (full)",
+        description: "List or search events with full details. For follow-ups only, see kanvas_list_events.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 25)" })),
+            search: Type.Optional(Type.String({ description: "Search keyword" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listEvents(params.first, params.search, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_event",
+        label: "Get Event",
+        description: "Get full details for an event by ID, including versions, dates, tags, and custom fields.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Event ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getEvent(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_create_event",
+        label: "Create Event",
+        description: "Create an event with dates. Supports linking to resources (leads, deals) and categorization. For a simple lead follow-up, use kanvas_create_follow_up.",
+        parameters: Type.Object({
+            name: Type.String({ description: "Event name" }),
+            slug: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            dates: Type.Array(EventDateInput, { description: "At least one date (YYYY-MM-DD + HH:MM times)" }),
+            type_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            class_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            category_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            theme_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            theme_area_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            resources: Type.Optional(Type.Array(EventResourceInput)),
+            participants: Type.Optional(Type.Array(Type.String())),
+            tags: Type.Optional(Type.Array(TagInput)),
+            custom_fields: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createEvent(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_event",
+        label: "Update Event",
+        description: "Update an event's name, description, dates, status, or linked resources.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Event ID" }),
+            name: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            dates: Type.Optional(Type.Array(EventDateInput)),
+            type_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            class_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            category_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            resources_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            resources_type: Type.Optional(Type.String()),
+            tags: Type.Optional(Type.Array(TagInput)),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updateEvent(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_event",
+        label: "Delete Event",
+        description: "Delete an event by ID.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Event ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteEvent(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_follow_event",
+        label: "Follow Event",
+        description: "Subscribe a user to event updates.",
+        parameters: Type.Object({
+            entity_id: Type.String({ description: "Event UUID" }),
+            user_id: Type.Union([Type.String(), Type.Number()], { description: "User ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.followEvent(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_unfollow_event",
+        label: "Unfollow Event",
+        description: "Unsubscribe a user from event updates.",
+        parameters: Type.Object({
+            entity_id: Type.String({ description: "Event UUID" }),
+            user_id: Type.Union([Type.String(), Type.Number()], { description: "User ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.unFollowEvent(params));
+        },
+    });
+}

package/dist/tools/orders.js

@@ -1,6 +1,42 @@
 import { Type } from "@sinclair/typebox";
 import { toolResult } from "./helpers.js";
+const OrderLineItemInput = Type.Object({
+    variant_id: Type.Union([Type.String(), Type.Number()], { description: "Variant ID" }),
+    quantity: Type.Number({ description: "Quantity" }),
+    price: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+    metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    channel_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+});
+const OrderAddressInput = Type.Object({
+    address: Type.String(),
+    address_2: Type.Optional(Type.String()),
+    city: Type.Optional(Type.String()),
+    state: Type.Optional(Type.String()),
+    zip: Type.Optional(Type.String()),
+    country: Type.Optional(Type.String()),
+    is_default: Type.Optional(Type.Boolean()),
+});
+const OrderBillingInput = Type.Object({
+    address: Type.String(),
+    address2: Type.Optional(Type.String()),
+    city: Type.String(),
+    state: Type.String(),
+    zip: Type.String(),
+    country: Type.String(),
+});
+const OrderCustomerInput = Type.Object({
+    id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+    firstname: Type.String(),
+    lastname: Type.Optional(Type.String()),
+    contacts: Type.Optional(Type.Array(Type.Object({
+        value: Type.String(),
+        contacts_types_id: Type.Number(),
+        weight: Type.Optional(Type.Number()),
+    }))),
+    address: Type.Optional(Type.Array(OrderAddressInput)),
+});
 export function registerOrdersTools(api, service, ensureAuth) {
+    // ── Read ───────────────────────────────────────────────────
     api.registerTool({
         name: "kanvas_search_orders",
         label: "Search Orders",
@@ -26,4 +62,153 @@ export function registerOrdersTools(api, service, ensureAuth) {
             return toolResult(await service.getOrder(params.id));
         },
     });
+    // ── Lookups ────────────────────────────────────────────────
+    api.registerTool({
+        name: "kanvas_list_order_statuses",
+        label: "List Order Statuses",
+        description: "List order statuses. Use to find status slugs for status transitions.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listOrderStatuses(params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_order_types",
+        label: "List Order Types",
+        description: "List order types (e.g. standard, subscription). Each type has its own status pipeline.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listOrderTypes(params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_regions",
+        label: "List Regions",
+        description: "List regions for order creation. Regions define currency and tax rules.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listRegions(params.first));
+        },
+    });
+    // ── Write ──────────────────────────────────────────────────
+    api.registerTool({
+        name: "kanvas_create_draft_order",
+        label: "Create Draft Order",
+        description: "Create a draft order. Requires email, customer (firstname), region_id, and at least one item with variant_id+quantity. Use kanvas_list_regions to get a region ID and kanvas_list_variants to find variants.",
+        parameters: Type.Object({
+            email: Type.String({ description: "Customer email" }),
+            phone: Type.Optional(Type.String()),
+            customer: OrderCustomerInput,
+            region_id: Type.Union([Type.String(), Type.Number()], { description: "Region ID (use kanvas_list_regions)" }),
+            items: Type.Array(OrderLineItemInput, { description: "Line items" }),
+            channel_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Channel ID" })),
+            billing_address: Type.Optional(OrderBillingInput),
+            shipping_address: Type.Optional(OrderAddressInput),
+            note: Type.Optional(Type.String()),
+            metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createDraftOrder(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_order",
+        label: "Update Order",
+        description: "Update an order's items, fulfillment status, payment status, or metadata.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Order ID" }),
+            items: Type.Optional(Type.Array(OrderLineItemInput)),
+            fulfillment_status: Type.Optional(Type.String()),
+            status: Type.Optional(Type.String()),
+            payment_status: Type.Optional(Type.String()),
+            metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            metadata_action: Type.Optional(Type.Union([Type.Literal("MERGE"), Type.Literal("REPLACE")])),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updateOrder(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_draft_order_status",
+        label: "Update Draft Order Status",
+        description: "Change a draft order's status (PENDING, COMPLETED, DRAFT, CANCELED, FAILED).",
+        parameters: Type.Object({
+            order_id: Type.String({ description: "Order ID" }),
+            status: Type.Union([
+                Type.Literal("PENDING"),
+                Type.Literal("COMPLETED"),
+                Type.Literal("DRAFT"),
+                Type.Literal("CANCELED"),
+                Type.Literal("FAILED"),
+            ], { description: "New status" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.updateDraftOrderStatus(params.order_id, params.status));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_transition_order_status",
+        label: "Transition Order Status",
+        description: "Move an order through its status pipeline using a status slug (from kanvas_list_order_statuses).",
+        parameters: Type.Object({
+            order_id: Type.String({ description: "Order ID" }),
+            status_slug: Type.Optional(Type.String({ description: "Target status slug" })),
+            date: Type.Optional(Type.String({ description: "Transition date" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.transitionOrderStatus(params.order_id, params.status_slug, params.date));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_order_change_customer",
+        label: "Change Order Customer",
+        description: "Change the customer on an order. Requires xKanvasKey (app-key authenticated).",
+        parameters: Type.Object({
+            order_id: Type.String({ description: "Order ID" }),
+            customer_id: Type.String({ description: "New customer ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.changeOrderCustomer(params.order_id, params.customer_id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_order",
+        label: "Delete Order",
+        description: "Delete an order.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Order ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteOrder(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_send_order_email",
+        label: "Send Order Email",
+        description: "Send an email for an order (confirmation, receipt, etc.). Requires xKanvasKey (app-key authenticated).",
+        parameters: Type.Object({
+            order_id: Type.String({ description: "Order ID" }),
+            template: Type.Optional(Type.String({ description: "Email template name" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.sendOrderEmail(params.order_id, params.template));
+        },
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kanvas/openclaw-plugin",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Connects agents to Kanvas — your company's nervous system for CRM, inventory, orders, and messaging.",
   "license": "MIT",
   "repository": {