@crmy/openclaw-plugin 0.5.11 → 0.6.0

package/SKILL.md

@@ -1,140 +1,278 @@
 ---
 name: crmy
-description: CRMy agent — manages contacts, accounts, deals, and pipeline using the CRMy CRM. Search before creating. Log every meaningful interaction. Always suggest next steps.
+description: CRMy agent — manages contacts, accounts, deals, and pipeline. Search before creating. Log every meaningful interaction. Always suggest a next step.
 ---
 
 # CRMy — Your AI-Native CRM
 
-You have full access to CRMy, an agent-first CRM. You are not just a tool caller — you are a proactive sales and relationship intelligence assistant. Think like a great CRM manager: remember context, connect the dots, and always suggest what should happen next.
+You have full access to CRMy via the **`crmy` tool**. Every call takes an `action` string and an optional `params` object.
+
+```
+crmy({ action: "<action>", params: { ... } })
+```
 
 ---
 
 ## Core Principles
 
 ### 1. Search before you create
-**Always** run `crmy_search` or a specific search tool before creating any record. Duplicates are expensive. If you find a match, confirm with the user before proceeding.
+Always search before creating any record. Duplicates are expensive.
 
 ```
-User: "Add a contact for Sarah Chen at Acme"
-→ crmy_contact_search("Sarah Chen") first
-→ If found: "I found Sarah Chen at Acme Corp — want me to update her record instead?"
-→ If not found: create with crmy_contact_create
+User: "Add Sarah Chen at Acme"
+→ crmy({ action: "contact.search", params: { q: "Sarah Chen" } })
+→ Found? Confirm before updating. Not found? Create.
 ```
 
 ### 2. Log every meaningful interaction
-Any time the user mentions talking to someone, having a meeting, sending a proposal, or receiving news about a deal — offer to log it as an activity. Don't wait to be asked.
+Any time the user mentions a call, meeting, email, or deal news — offer to log it. Don't wait to be asked.
 
 ```
-User: "Just got off a call with Marcus, he's interested in the enterprise plan"
-→ Log call via crmy_contact_log_activity
-→ Suggest advancing the opportunity stage
-→ Ask if there's a follow-up to schedule
+User: "Just got off a call with Marcus, he's interested in enterprise"
+→ crmy({ action: "contact.log_activity", params: { activity_type: "call", subject_type: "contact", subject_id: "<marcus-id>", summary: "...", outcome: "positive" } })
+→ Offer to advance the opportunity stage
 ```
 
 ### 3. Link everything
-Contacts belong to accounts. Opportunities belong to accounts and contacts. When creating any record, ask about relationships if they're not provided.
+Contacts belong to accounts. Opportunities belong to accounts. Ask about relationships when not provided.
 
 ### 4. Always suggest a next step
-After any CRM action, end with one concrete suggestion:
 - After logging a call → "Want me to advance the deal stage or set a follow-up?"
 - After creating a contact → "Should I create an opportunity for this relationship?"
 - After advancing a stage → "Want me to log what triggered this move?"
 
 ---
 
-## CRMy Data Model
+## Actions Reference
+
+### `search`
+Global cross-entity search — contacts, accounts, opportunities, activities.
+
+```
+crmy({ action: "search", params: { q: "Acme", limit: 10 } })
+```
+| Param | Type | Notes |
+|-------|------|-------|
+| q | string | **required** — search query |
+| limit | number | max results (default 10) |
+
+---
+
+### `contact.search`
+Search contacts by name, email, company, or keyword.
+
+```
+crmy({ action: "contact.search", params: { q: "Sarah", stage: "customer", limit: 20 } })
+```
+| Param | Type | Notes |
+|-------|------|-------|
+| q | string | **required** |
+| stage | string | filter by lifecycle stage |
+| limit | number | default 20 |
+
+---
+
+### `contact.create`
+Create a new contact.
+
+```
+crmy({ action: "contact.create", params: {
+  name: "Sarah Chen",
+  email: "sarah@acme.com",
+  phone: "+1 555 0100",
+  title: "VP Engineering",
+  account_id: "<uuid>",
+  lifecycle_stage: "prospect",
+  notes: "Met at SaaStr 2026"
+}})
+```
+| Param | Required |
+|-------|----------|
+| name | ✓ |
+| email, phone, title, account_id, lifecycle_stage, notes | optional |
+
+---
+
+### `contact.update`
+Update fields on an existing contact.
+
+```
+crmy({ action: "contact.update", params: { id: "<uuid>", email: "new@acme.com" } })
+```
+`id` is **required**. Include only the fields to change.
+
+---
+
+### `contact.set_stage`
+Change a contact's lifecycle stage.
+
+```
+crmy({ action: "contact.set_stage", params: { id: "<uuid>", stage: "customer", note: "Signed contract" } })
+```
+**Lifecycle stages in order:** `lead` → `prospect` → `customer` → `churned` / `partner`
+
+---
+
+### `contact.log_activity`
+Log a call, email, meeting, demo, proposal, or note against any record.
 
-### Contacts
-People you have relationships with. Key fields: `name`, `email`, `phone`, `title`, `account_id`, `lifecycle_stage`.
+```
+crmy({ action: "contact.log_activity", params: {
+  activity_type: "call",
+  subject_type: "contact",
+  subject_id: "<uuid>",
+  summary: "Discussed enterprise pricing",
+  outcome: "positive",
+  duration_minutes: 30,
+  notes: "Wants a proposal by Friday"
+}})
+```
+| Param | Required | Values |
+|-------|----------|--------|
+| activity_type | ✓ | call, email, meeting, demo, proposal, note |
+| subject_type | ✓ | contact, account, opportunity |
+| subject_id | ✓ | UUID of the record |
+| summary | ✓ | short description |
+| outcome | | positive, neutral, negative |
+| duration_minutes | | for calls and meetings |
+| performed_at | | ISO 8601 (defaults to now) |
+| notes | | detailed notes |
+
+---
+
+### `account.search`
+Search companies/accounts.
+
+```
+crmy({ action: "account.search", params: { q: "Acme", industry: "SaaS", limit: 20 } })
+```
+
+---
+
+### `account.create`
+Create a new company/account.
+
+```
+crmy({ action: "account.create", params: {
+  name: "Acme Corp",
+  domain: "acme.com",
+  industry: "SaaS",
+  size: "51-200"
+}})
+```
+`name` is **required**.
+
+---
+
+### `opportunity.search`
+Search deals/opportunities.
 
-**Lifecycle stages** (in order):
-- `lead` — heard of them, no real relationship yet
-- `prospect` — actively exploring a fit
-- `customer` — paying customer
-- `churned` — was a customer, no longer active
-- `partner` — strategic relationship, not a direct sale
+```
+crmy({ action: "opportunity.search", params: { q: "Acme", stage: "proposal", limit: 20 } })
+```
+| Param | Notes |
+|-------|-------|
+| q | **required** |
+| stage | filter by deal stage |
+| account_id | filter by account UUID |
 
-Use `crmy_contact_set_lifecycle` when a relationship meaningfully changes.
+---
 
-### Accounts
-Companies and organizations. Key fields: `name`, `domain`, `industry`, `size`.
+### `opportunity.create`
+Create a new deal.
 
-### Opportunities (Deals)
-Revenue-generating relationships. Key fields: `name`, `account_id`, `value`, `stage`, `close_date`.
+```
+crmy({ action: "opportunity.create", params: {
+  name: "Acme Corp — Enterprise",
+  account_id: "<uuid>",
+  value: 48000,
+  stage: "prospecting",
+  close_date: "2026-09-30"
+}})
+```
+`name` is **required**.
 
-**Deal stages** (typical progression):
-- `prospecting` → `qualification` → `proposal` → `negotiation` → `closed_won` / `closed_lost`
+---
 
-Use `crmy_opportunity_advance_stage` to move a deal. Always include a `note` explaining why.
+### `opportunity.advance`
+Move a deal to a new stage.
 
-### Activities
-The record of every interaction. Always specify `activity_type`:
-- `call` — phone or video call
-- `email` — email sent or received
-- `meeting` — in-person or virtual meeting
-- `demo` — product demonstration
-- `proposal` — proposal sent
-- `note` — internal note or observation
+```
+crmy({ action: "opportunity.advance", params: {
+  id: "<uuid>",
+  stage: "closed_won",
+  note: "Signed MSA received",
+  lost_reason: ""
+}})
+```
+`id` and `stage` are **required**. Always include a `note`.
 
-Set `outcome` to `positive`, `neutral`, or `negative` based on how it went.
+**Deal stages:** `prospecting` → `qualification` → `proposal` → `negotiation` → `closed_won` / `closed_lost`
+
+---
+
+### `pipeline.summary`
+Get pipeline analytics grouped by stage (or owner/forecast_cat).
+
+```
+crmy({ action: "pipeline.summary", params: { group_by: "stage" } })
+```
 
 ---
 
 ## Multi-Step Workflows
 
 ### "Log a call I just had"
-1. Search for the contact first (`crmy_contact_search`)
-2. Log the activity (`crmy_contact_log_activity`) with type `call`, the summary, and outcome
-3. If they mentioned a deal → search for the opportunity (`crmy_opportunity_search`) and offer to advance its stage
-4. Suggest: "Want me to update [contact]'s lifecycle stage to reflect this?"
+1. `contact.search` — find the contact
+2. `contact.log_activity` — type: call, summary, outcome
+3. If deal mentioned → `opportunity.search` → offer `opportunity.advance`
+4. Suggest: "Want me to update their lifecycle stage?"
 
 ### "We just closed a deal"
-1. Find the opportunity (`crmy_opportunity_search`)
-2. Advance to `closed_won` with a note (`crmy_opportunity_advance_stage`)
-3. Update the primary contact's lifecycle to `customer` (`crmy_contact_set_lifecycle`)
-4. Log a closing activity (`crmy_contact_log_activity`, type: `meeting`, outcome: `positive`)
-5. Celebrate, then ask: "Should I set up a follow-up for onboarding?"
-
-### "How is the pipeline looking?"
-1. Pull the summary (`crmy_pipeline_summary`)
-2. Highlight: total value, deals by stage, any deals that haven't moved recently
-3. Proactively ask: "Want me to look at any of these deals in detail?"
-
-### "Find everyone at Acme Corp"
-1. Search accounts for Acme (`crmy_account_search`)
-2. Search contacts at that account (`crmy_contact_search` with the account name or id)
-3. Present a clean summary: contacts, their titles, lifecycle stages, and any open deals
+1. `opportunity.search` — find the deal
+2. `opportunity.advance` — stage: closed_won + note
+3. `contact.set_stage` — primary contact → customer
+4. `contact.log_activity` — type: meeting, outcome: positive
+5. Celebrate, then: "Should I set up an onboarding follow-up?"
+
+### "How's the pipeline?"
+1. `pipeline.summary` — group_by: stage
+2. Present as a table: stage | deal count | total value
+3. Highlight any deals stuck in the same stage for 30+ days
+4. Ask: "Want me to look at any of these in detail?"
 
 ### "New lead from the conference"
-1. Search for the contact first (avoid duplicates)
-2. Create the contact with `lifecycle_stage: lead` (`crmy_contact_create`)
-3. Search for or create their company (`crmy_account_search` / `crmy_account_create`)
-4. Link them via `account_id`
-5. Log where you met them as an activity (type: `meeting`)
-6. Ask: "Want to create an opportunity for this relationship?"
+1. `contact.search` — avoid duplicate
+2. `contact.create` — lifecycle_stage: lead
+3. `account.search` or `account.create` — find/create their company
+4. `contact.update` — link account_id
+5. `contact.log_activity` — type: meeting (where you met)
+6. Ask: "Want to create an opportunity?"
+
+### "Who do we know at Stripe?"
+1. `account.search` — q: "Stripe"
+2. `contact.search` — q: "Stripe" (or filter by account_id)
+3. Present: name, title, lifecycle stage, any open deals
 
 ---
 
-## Tone and Presentation
+## Presentation Guidelines
 
-- **Be concise.** When returning search results, summarize — don't dump raw JSON.
-- **Use names, not UUIDs** in your responses.
-- **Confirm before bulk operations.** If the user wants to update 5 contacts, confirm scope first.
-- **When something fails**, explain what went wrong in plain language and suggest a fix (e.g., "The server isn't reachable — is `npx @crmy/cli server` running?").
-- **Format pipeline data** as a clean table or bullet list, not raw numbers.
+- **Summarize results** — don't dump raw JSON. Use names, not UUIDs.
+- **Format pipeline data** as a table or bullets, not raw numbers.
+- **Confirm before bulk changes** — "I'll update 5 contacts — proceed?"
+- **On API errors** — explain in plain English and suggest a fix:
+  - "Server not reachable — is `npx @crmy/cli server` running?"
+  - "Record not found — want me to search first?"
 
 ---
 
-## Example Interactions
-
-> "Sarah from Acme said she's ready to move forward"
-→ Search for Sarah → find opportunity → advance stage → log activity → update lifecycle → suggest next step
-
-> "Pull up our pipeline"
-→ `crmy_pipeline_summary` → present as table with stage, deal count, total value → highlight any stuck deals
-
-> "Who do we know at Stripe?"
-→ `crmy_account_search("Stripe")` → `crmy_contact_search` filtered by account → list contacts with titles and stages
+## Quick Examples
 
-> "Log that I sent a proposal to Marcus at Zendesk"
-→ Find Marcus → log activity (type: proposal) → ask if the deal stage should move to `proposal`
+| User says | Actions |
+|-----------|---------|
+| "Sarah from Acme is ready to move forward" | contact.search → opportunity.search → opportunity.advance → contact.log_activity → contact.set_stage |
+| "Pull up our pipeline" | pipeline.summary → present table → offer drill-down |
+| "Who do we know at Stripe?" | account.search → contact.search → list with stages |
+| "Log that I sent a proposal to Marcus" | contact.search → contact.log_activity (type: proposal) → offer opportunity.advance |
+| "Add a new lead: Jamie Lee, CTO at Horizon" | contact.search (check dup) → contact.create → account.search → link account |

package/dist/index.d.ts

@@ -1,16 +1,17 @@
+interface ToolInput {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description: string;
+        enum?: string[];
+    }>;
+    required?: string[];
+}
 interface ToolDef {
     id: string;
     name: string;
     description: string;
-    input: {
-        type: 'object';
-        properties: Record<string, {
-            type: string;
-            description: string;
-            enum?: string[];
-        }>;
-        required?: string[];
-    };
+    input: ToolInput;
     handler: (input: Record<string, unknown>) => Promise<unknown>;
 }
 interface OpenClawApi {

package/dist/index.js

@@ -71,219 +71,73 @@ var CrmyClient = class {
 };
 
 // src/index.ts
+var ROUTES = {
+  // Global cross-entity search
+  "search": async (c, p) => c.get("/search", { q: str(p.q), limit: num(p.limit, 10) }),
+  // Contacts
+  "contact.search": async (c, p) => c.get("/contacts", { q: str(p.q), stage: str(p.stage), limit: num(p.limit, 20) }),
+  "contact.create": async (c, p) => c.post("/contacts", p),
+  "contact.update": async (c, { id, ...rest }) => c.patch(`/contacts/${str(id)}`, rest),
+  "contact.set_stage": async (c, { id, ...rest }) => c.patch(`/contacts/${str(id)}`, rest),
+  "contact.log_activity": async (c, p) => c.post("/activities", p),
+  // Accounts
+  "account.search": async (c, p) => c.get("/accounts", { q: str(p.q), industry: str(p.industry), limit: num(p.limit, 20) }),
+  "account.create": async (c, p) => c.post("/accounts", p),
+  // Opportunities
+  "opportunity.search": async (c, p) => c.get("/opportunities", {
+    q: str(p.q),
+    stage: str(p.stage),
+    account_id: str(p.account_id),
+    limit: num(p.limit, 20)
+  }),
+  "opportunity.create": async (c, p) => c.post("/opportunities", p),
+  "opportunity.advance": async (c, { id, ...rest }) => c.patch(`/opportunities/${str(id)}`, rest),
+  // Analytics
+  "pipeline.summary": async (c, p) => c.get("/analytics/pipeline", { group_by: str(p.group_by) ?? "stage" })
+};
+var VALID_ACTIONS = Object.keys(ROUTES);
+function str(v) {
+  return v != null && v !== "" ? String(v) : void 0;
+}
+function num(v, fallback) {
+  const n = Number(v);
+  return isNaN(n) ? fallback : n;
+}
 var index_default = (api) => {
   const cfg = resolveConfig(api.config);
   const client = new CrmyClient(cfg);
   api.registerTool({
-    id: "crmy_search",
-    name: "CRMy: Search",
-    description: "Search across all CRMy records \u2014 contacts, accounts, opportunities, activities, and more. Use this as a first step when you are not sure which record type the user is referring to.",
-    input: {
-      type: "object",
-      properties: {
-        q: { type: "string", description: "Search query" },
-        limit: { type: "number", description: "Max results (default 10)" }
-      },
-      required: ["q"]
-    },
-    handler: async (input) => client.get("/search", { q: input.q, limit: input.limit ?? 10 })
-  });
-  api.registerTool({
-    id: "crmy_contact_search",
-    name: "CRMy: Search Contacts",
-    description: "Search for contacts by name, email, company, or any keyword. Supports optional lifecycle stage filter.",
-    input: {
-      type: "object",
-      properties: {
-        q: { type: "string", description: "Search query (name, email, company, etc.)" },
-        stage: { type: "string", description: "Filter by lifecycle stage (e.g. prospect, customer, churned)" },
-        limit: { type: "number", description: "Max results (default 20)" }
-      },
-      required: ["q"]
-    },
-    handler: async (input) => client.get("/contacts", { q: input.q, stage: input.stage, limit: input.limit ?? 20 })
-  });
-  api.registerTool({
-    id: "crmy_contact_create",
-    name: "CRMy: Create Contact",
-    description: "Create a new contact in CRMy. At minimum provide a name. Email, phone, title, and account_id are optional.",
+    id: "crmy",
+    name: "CRMy CRM",
+    // Keep the top-level description short — OpenClaw loads it for every turn.
+    // Detail lives in SKILL.md which is loaded only when this tool is active.
+    description: "Interact with the CRMy CRM. Specify an action and optional params. Valid actions: " + VALID_ACTIONS.join(", ") + ". See SKILL.md for param shapes and workflow guidance.",
     input: {
       type: "object",
       properties: {
-        name: { type: "string", description: "Full name (required)" },
-        email: { type: "string", description: "Email address" },
-        phone: { type: "string", description: "Phone number" },
-        title: { type: "string", description: "Job title" },
-        account_id: { type: "string", description: "UUID of the associated account/company" },
-        lifecycle_stage: { type: "string", description: "Initial lifecycle stage (e.g. prospect, lead, customer)" },
-        notes: { type: "string", description: "Any initial notes about this contact" }
-      },
-      required: ["name"]
-    },
-    handler: async (input) => client.post("/contacts", input)
-  });
-  api.registerTool({
-    id: "crmy_contact_update",
-    name: "CRMy: Update Contact",
-    description: "Update fields on an existing contact. Provide the contact id and any fields to change.",
-    input: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Contact UUID (required)" },
-        name: { type: "string", description: "Updated name" },
-        email: { type: "string", description: "Updated email" },
-        phone: { type: "string", description: "Updated phone" },
-        title: { type: "string", description: "Updated job title" },
-        account_id: { type: "string", description: "Move to a different account UUID" }
-      },
-      required: ["id"]
-    },
-    handler: async ({ id, ...rest }) => client.patch(`/contacts/${id}`, rest)
-  });
-  api.registerTool({
-    id: "crmy_contact_log_activity",
-    name: "CRMy: Log Activity",
-    description: "Log a call, email, meeting, or other activity against a contact, account, or opportunity. Provide subject_type + subject_id to attach it to the right record.",
-    input: {
-      type: "object",
-      properties: {
-        activity_type: {
-          type: "string",
-          description: "Type of activity \u2014 e.g. call, email, meeting, demo, proposal, note"
-        },
-        subject_type: {
+        action: {
           type: "string",
-          description: "Record type the activity is attached to: contact, account, or opportunity",
-          enum: ["contact", "account", "opportunity"]
+          description: "CRMy action to perform (see SKILL.md for the full list).",
+          enum: VALID_ACTIONS
         },
-        subject_id: { type: "string", description: "UUID of the contact, account, or opportunity" },
-        summary: { type: "string", description: "Short summary of what happened" },
-        outcome: { type: "string", description: "Outcome of the activity (e.g. positive, neutral, negative)" },
-        performed_at: { type: "string", description: "ISO 8601 timestamp (defaults to now)" },
-        duration_minutes: { type: "number", description: "Duration in minutes (for calls and meetings)" },
-        notes: { type: "string", description: "Detailed notes" }
-      },
-      required: ["activity_type", "subject_type", "subject_id", "summary"]
-    },
-    handler: async (input) => client.post("/activities", input)
-  });
-  api.registerTool({
-    id: "crmy_contact_set_lifecycle",
-    name: "CRMy: Set Contact Lifecycle Stage",
-    description: "Change the lifecycle stage of a contact (e.g. lead \u2192 prospect \u2192 customer \u2192 churned).",
-    input: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Contact UUID" },
-        stage: { type: "string", description: "New lifecycle stage (e.g. lead, prospect, customer, churned)" },
-        note: { type: "string", description: "Optional note explaining the stage change" }
-      },
-      required: ["id", "stage"]
-    },
-    handler: async ({ id, ...rest }) => client.patch(`/contacts/${id}`, rest)
-  });
-  api.registerTool({
-    id: "crmy_account_search",
-    name: "CRMy: Search Accounts",
-    description: "Search for companies/accounts by name, industry, or keyword.",
-    input: {
-      type: "object",
-      properties: {
-        q: { type: "string", description: "Search query (company name, domain, etc.)" },
-        industry: { type: "string", description: "Filter by industry" },
-        limit: { type: "number", description: "Max results (default 20)" }
-      },
-      required: ["q"]
-    },
-    handler: async (input) => client.get("/accounts", { q: input.q, industry: input.industry, limit: input.limit ?? 20 })
-  });
-  api.registerTool({
-    id: "crmy_account_create",
-    name: "CRMy: Create Account",
-    description: "Create a new company/account record in CRMy.",
-    input: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Company name (required)" },
-        domain: { type: "string", description: "Company website domain (e.g. acme.com)" },
-        industry: { type: "string", description: "Industry sector" },
-        size: { type: "string", description: "Company size (e.g. 1-10, 11-50, 51-200, 201-1000, 1000+)" },
-        notes: { type: "string", description: "Any initial notes about this company" }
-      },
-      required: ["name"]
-    },
-    handler: async (input) => client.post("/accounts", input)
-  });
-  api.registerTool({
-    id: "crmy_opportunity_search",
-    name: "CRMy: Search Opportunities",
-    description: "Search for deals/opportunities by name, account, or stage.",
-    input: {
-      type: "object",
-      properties: {
-        q: { type: "string", description: "Search query (deal name, account, etc.)" },
-        stage: { type: "string", description: "Filter by deal stage (e.g. prospecting, proposal, closed_won)" },
-        account_id: { type: "string", description: "Filter by account UUID" },
-        limit: { type: "number", description: "Max results (default 20)" }
-      },
-      required: ["q"]
-    },
-    handler: async (input) => client.get("/opportunities", {
-      q: input.q,
-      stage: input.stage,
-      account_id: input.account_id,
-      limit: input.limit ?? 20
-    })
-  });
-  api.registerTool({
-    id: "crmy_opportunity_create",
-    name: "CRMy: Create Opportunity",
-    description: "Create a new deal/opportunity in CRMy. Provide a name and optionally an account, value, and stage.",
-    input: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Deal name (required)" },
-        account_id: { type: "string", description: "Associated account UUID" },
-        value: { type: "number", description: "Deal value in your base currency" },
-        stage: { type: "string", description: "Initial deal stage (defaults to prospecting)" },
-        close_date: { type: "string", description: "Expected close date (ISO 8601, e.g. 2026-06-30)" },
-        notes: { type: "string", description: "Any notes about this deal" }
-      },
-      required: ["name"]
-    },
-    handler: async (input) => client.post("/opportunities", input)
-  });
-  api.registerTool({
-    id: "crmy_opportunity_advance_stage",
-    name: "CRMy: Advance Opportunity Stage",
-    description: "Move a deal to a new stage (e.g. proposal \u2192 negotiation \u2192 closed_won). Optionally add a note.",
-    input: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Opportunity UUID (required)" },
-        stage: { type: "string", description: "New stage name (required)" },
-        note: { type: "string", description: "Note explaining the stage transition" },
-        lost_reason: { type: "string", description: "If closing as lost, the reason" }
+        params: {
+          type: "object",
+          description: "Parameters for the chosen action. Shape varies by action \u2014 see SKILL.md. All fields are optional except where noted (e.g. id for updates, name for creates)."
+        }
       },
-      required: ["id", "stage"]
+      required: ["action"]
     },
-    handler: async ({ id, ...rest }) => client.patch(`/opportunities/${id}`, rest)
-  });
-  api.registerTool({
-    id: "crmy_pipeline_summary",
-    name: "CRMy: Pipeline Summary",
-    description: 'Get a summary of the sales pipeline \u2014 total deal count and value by stage. Useful for answering questions like "how many deals do we have?" or "what is our pipeline worth?"',
-    input: {
-      type: "object",
-      properties: {
-        group_by: {
-          type: "string",
-          description: "Group results by: stage (default), owner, or forecast_cat",
-          enum: ["stage", "owner", "forecast_cat"]
-        }
+    handler: async (input) => {
+      const action = str(input.action);
+      if (!action || !ROUTES[action]) {
+        throw new Error(
+          `Unknown CRMy action "${action}". Valid actions: ${VALID_ACTIONS.join(", ")}`
+        );
       }
-    },
-    handler: async (input) => client.get("/analytics/pipeline", { group_by: input.group_by ?? "stage" })
+      const params = input.params ?? {};
+      api.logger?.info(`[crmy] action=${action}`);
+      return ROUTES[action](client, params);
+    }
   });
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crmy/openclaw-plugin",
-  "version": "0.5.11",
+  "version": "0.6.0",
   "description": "CRMy plugin for OpenClaw — expose CRM tools (contacts, accounts, opportunities, pipeline) in any AI assistant running OpenClaw",
   "type": "module",
   "main": "dist/index.js",