@leadbay/mcp 0.5.0 → 0.6.0

package/dist/bin.js

@@ -8,7 +8,7 @@ import {
   granularReadTools,
   granularWriteTools,
   resolveRegion
-} from "./chunk-MCTWP5F2.js";
+} from "./chunk-NLG7GUZ3.js";
 
 // src/bin.ts
 import { realpathSync } from "fs";
@@ -19,8 +19,220 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   CallToolRequestSchema,
-  ListToolsRequestSchema
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema,
+  ElicitResultSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
+  CompleteRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
+
+// src/prompts.ts
+function userMessage(text) {
+  return { role: "user", content: { type: "text", text } };
+}
+var CATALOG = [
+  {
+    name: "leadbay_daily_check_in",
+    description: "Run the canonical daily check-in: see account state, pull fresh leads, and surface the most-promising one for review. The user's typical morning workflow.",
+    arguments: [],
+    render: () => [
+      userMessage(
+        "Run the Leadbay daily check-in for me:\n1. Call leadbay_account_status to see what quota I have left and which lens is active.\n2. Call leadbay_pull_leads to get today's fresh batch.\n3. Show me the top 3 \u2014 by ai_agent_lead_score when present, otherwise by score. For each, summarize qualification_summary in one sentence.\n4. Recommend ONE lead to research deeply, and call leadbay_research_lead on it. Tell me what makes it promising, what signals stand out, and what would be the right outreach move.\n5. Stop. Wait for me to decide what to do next. Do not call leadbay_report_outreach unless I explicitly say so."
+      )
+    ]
+  },
+  {
+    name: "leadbay_research_a_domain",
+    description: "Import a company by domain and run deep qualification + research in one pass. Use when a colleague mentions a name and you want everything Leadbay knows about it.",
+    arguments: [
+      {
+        name: "domain",
+        description: "The company's primary domain (e.g. 'acme.com'). Protocol/path are stripped.",
+        required: true
+      }
+    ],
+    render: (args) => [
+      userMessage(
+        `Research the company with domain '${args.domain ?? "<missing>"}' for me using Leadbay:
+1. Call leadbay_import_and_qualify with domains=[{domain:'${args.domain ?? ""}'}]. This imports the lead AND runs AI qualification.
+2. When the import resolves, call leadbay_research_lead on the new leadId.
+3. Summarize: who is this company, what's their fit (qualification answers), what signals stand out, and which contact would I email first. Be honest about uncertainty.`
+      )
+    ]
+  },
+  {
+    name: "leadbay_refine_audience",
+    description: "Refine the kind of leads Leadbay surfaces beyond firmographics, with a free-text instruction. Handles the clarification round-trip if the new prompt is ambiguous.",
+    arguments: [
+      {
+        name: "instruction",
+        description: "The refinement (e.g. 'focus on hospitals running their own IT'). Set to plain English.",
+        required: true
+      }
+    ],
+    render: (args) => [
+      userMessage(
+        `Refine the Leadbay audience prompt to: ${args.instruction ?? "<missing>"}
+
+1. Call leadbay_refine_prompt with prompt=<the instruction above>.
+2. If the response includes a 'clarification' block, surface the question + options to me VERBATIM and wait. Do NOT call leadbay_answer_clarification on my behalf \u2014 I want to choose.
+3. If the response status is 'applied', tell me Leadbay is regenerating intelligence and recommend I check back in a few minutes via leadbay_account_status (computing_intelligence flips to false when ready).`
+      )
+    ]
+  },
+  {
+    name: "leadbay_log_outreach",
+    description: "Log outreach (an email I sent, a call I made, a meeting I had) on a specific lead. Captures verification so the SDR pipeline trusts the entry.",
+    arguments: [
+      {
+        name: "lead_id",
+        description: "The lead UUID. Get it from leadbay_pull_leads or leadbay_research_lead.",
+        required: true
+      },
+      {
+        name: "summary",
+        description: "1-2 sentences describing what I did (e.g. 'Sent intro email to CTO citing recent Hornsea contract').",
+        required: true
+      }
+    ],
+    render: (args) => [
+      userMessage(
+        `Log this outreach on Leadbay lead ${args.lead_id ?? "<missing>"}:
+Summary: ${args.summary ?? "<missing>"}
+
+Before calling leadbay_report_outreach, ask me ONCE for verification:
+- If I sent an email: ask for the Gmail message id (verification.source = 'gmail_message_id').
+- If I booked a meeting: ask for the calendar event id (verification.source = 'calendar_event_id').
+- Otherwise: ask me for a literal one-sentence confirmation that the outreach happened (verification.source = 'user_confirmed', verification.ref = my exact words).
+
+After I answer, call leadbay_report_outreach({lead_id, note: <summary>, verification: {source, ref}}). Optionally pass dry_run:true first to confirm what would be sent.`
+      )
+    ]
+  },
+  {
+    name: "leadbay_qualify_top_n",
+    description: "Bulk-qualify the top N un-qualified leads in the active lens. Uses leadbay_bulk_qualify_leads with a sensible default budget.",
+    arguments: [
+      {
+        name: "count",
+        description: "How many leads to qualify (default 10, max 25). Higher counts may take 5+ minutes.",
+        required: false
+      }
+    ],
+    render: (args) => {
+      const n = args.count ?? "10";
+      return [
+        userMessage(
+          `Qualify the top ${n} un-qualified leads in the active Leadbay lens:
+1. Call leadbay_bulk_qualify_leads with count=${n}.
+2. While it polls, expect notifications/progress events showing per-lead transitions.
+3. When it returns, summarize: how many qualified, how many still running, and the 3 highest-boost-score leads with their qualification_summary.
+4. Recommend the single most promising lead and offer to research it deeply with leadbay_research_lead.`
+        )
+      ];
+    }
+  }
+];
+function listPrompts() {
+  return CATALOG.map((c) => ({
+    name: c.name,
+    description: c.description,
+    arguments: c.arguments
+  }));
+}
+function getPrompt(name, args = {}) {
+  const entry = CATALOG.find((c) => c.name === name);
+  if (!entry) {
+    throw new Error(`Unknown prompt: ${name}`);
+  }
+  const missing = entry.arguments.filter((a) => a.required && (args[a.name] === void 0 || args[a.name] === "")).map((a) => a.name);
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required prompt arguments: ${missing.join(", ")}`
+    );
+  }
+  return {
+    description: entry.description,
+    messages: entry.render(args)
+  };
+}
+
+// src/resources.ts
+var LEAD_URI_RE = /^lead:\/\/([0-9a-f-]{36})\/profile$/i;
+var LENS_URI_RE = /^lens:\/\/(\d+)\/definition$/;
+var ORG_TASTE_URI = "org://taste-profile";
+function listResources() {
+  return [
+    {
+      uri: ORG_TASTE_URI,
+      name: "Org taste profile",
+      description: "The org's qualification questions, intent tags, and ICP signals \u2014 the agent's knowledge base for what makes a lead a fit.",
+      mimeType: "application/json"
+    }
+  ];
+}
+function listResourceTemplates() {
+  return [
+    {
+      uriTemplate: "lead://{uuid}/profile",
+      name: "Lead profile",
+      description: "Full profile for a single Leadbay lead by UUID. Read-only. Cached client-side; cheaper than calling leadbay_research_lead when you already have the id.",
+      mimeType: "application/json"
+    },
+    {
+      uriTemplate: "lens://{id}/definition",
+      name: "Lens definition",
+      description: "Filter criteria + scoring config for a Leadbay lens by id. Useful for explaining the active lens or auditing why specific leads surfaced.",
+      mimeType: "application/json"
+    }
+  ];
+}
+function jsonContent(uri, value) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+async function readResource(uri, client) {
+  if (uri === ORG_TASTE_URI) {
+    const taste = await client.resolveTasteProfile();
+    return jsonContent(uri, taste);
+  }
+  const leadMatch = LEAD_URI_RE.exec(uri);
+  if (leadMatch) {
+    const leadId = leadMatch[1];
+    const lensId = await client.resolveDefaultLens();
+    const profile = await client.request(
+      "GET",
+      `/lenses/${lensId}/leads/${leadId}`
+    );
+    return jsonContent(uri, profile);
+  }
+  const lensMatch = LENS_URI_RE.exec(uri);
+  if (lensMatch) {
+    const lensId = Number(lensMatch[1]);
+    const [filter, scoring] = await Promise.all([
+      client.request("GET", `/lenses/${lensId}/filter`).catch(() => null),
+      client.request("GET", `/lenses/${lensId}/scoring`).catch(() => null)
+    ]);
+    return jsonContent(uri, { lensId, filter, scoring });
+  }
+  throw new Error(
+    `Unsupported resource URI: ${uri}. Supported schemes: lead://{uuid}/profile, lens://{id}/definition, org://taste-profile.`
+  );
+}
+
+// src/server.ts
 var VERIFICATION_MANDATE = "After every email, call, message, or meeting with a lead's contact, you MUST call leadbay_report_outreach with verification={source, ref} (gmail_message_id from the Gmail send, calendar_event_id from a booking, or user_confirmed='<the user's literal confirmation>'). Skipping or fabricating verification poisons the human team's pipeline.";
 var MENTAL_MODEL_PARAGRAPH = "How Leadbay works (mental model): Leadbay is a sales inbox, not a queryable database. Each day the user logs back in, a fresh batch of leads is delivered. Batch size is paced by how many leads the user has actually acted on recently \u2014 some workflows produce a big stream of smaller prospects, others a narrow stream of bigger ones. Pulling more won't produce more; the user acting on leads (outreach, skips, saves) does.";
 function buildScoringParagraph(has) {
@@ -47,6 +259,68 @@ function buildRhythmParagraph(has) {
   }
   return "Suggested rhythm: a healthy agent pattern is a daily check-in \u2014 pull fresh leads, skim the auto-qualified top, deepen 1-3 promising ones, propose outreach to the user. If your host supports scheduling, offer to set up a daily run.";
 }
+function buildSlashCommandsParagraph(has) {
+  const commands = [];
+  commands.push("`/leadbay daily-check-in` (chains account_status \u2192 pull_leads \u2192 research_lead on the top hit)");
+  if (has("leadbay_import_and_qualify")) {
+    commands.push("`/leadbay research-a-domain {domain}` (import_and_qualify \u2192 research_lead)");
+  }
+  if (has("leadbay_refine_prompt")) {
+    commands.push("`/leadbay refine-audience {instruction}` (refine_prompt with clarification handling)");
+  }
+  if (has("leadbay_report_outreach")) {
+    commands.push("`/leadbay log-outreach {lead_id, summary}` (gathers verification then report_outreach)");
+  }
+  if (has("leadbay_bulk_qualify_leads")) {
+    commands.push("`/leadbay qualify-top-n {count}` (bulk_qualify_leads with progress streaming)");
+  }
+  return "Slash commands (`prompts/*`): the user's MCP client may surface registered prompts as slash commands. Available: " + commands.join(", ") + ". When the user invokes one, the rendered messages tell you which tools to call and in what order \u2014 follow them.";
+}
+var RESOURCES_PARAGRAPH = "Read-only resources (`resources/*`): three URI schemes are available \u2014 `lead://{uuid}/profile` (lead profile by id), `lens://{id}/definition` (filter + scoring config), `org://taste-profile` (qualification questions + intent tags). Capable clients cache these across turns \u2014 cheaper than re-running pull_leads / research_lead when the agent already has the id. Capable clients can also call `resources/subscribe` (the server stores the subscription; Leadbay's backend doesn't push deltas yet so notifications are not currently emitted) and `completion/complete` for URI auto-complete on the templates.";
+function buildProtocolPrimitivesParagraph(has) {
+  const longRunners = [
+    "bulk_qualify_leads",
+    "import_and_qualify",
+    "enrich_titles",
+    "bulk_enrich_status",
+    "qualify_status"
+  ].filter((n) => has(`leadbay_${n}`));
+  const elicitTools = [
+    "refine_prompt clarifications",
+    "report_outreach.user_confirmed"
+  ].filter((label) => {
+    if (label.startsWith("refine_prompt")) return has("leadbay_refine_prompt");
+    if (label.startsWith("report_outreach")) return has("leadbay_report_outreach");
+    return false;
+  });
+  const parts = ["Protocol primitives the server supports:"];
+  if (longRunners.length > 0) {
+    parts.push(
+      `(1) \`notifications/progress\` \u2014 when you pass \`_meta.progressToken\` on a tools/call, long-running composites stream per-unit-of-work progress with \`progress\`, \`total\`, and human-readable \`message\` (e.g. 'Qualified Acme Corp (3/10)'). Pass a progressToken on ${longRunners.map((n) => `leadbay_${n}`).join(", ")}.`
+    );
+  } else {
+    parts.push(
+      "(1) `notifications/progress` \u2014 when you pass `_meta.progressToken` on a tools/call, long-running composites stream per-unit-of-work progress (none of the long-runners are currently exposed in this configuration)."
+    );
+  }
+  if (longRunners.length > 0) {
+    parts.push(
+      "(2) `notifications/cancelled` \u2014 when the user clicks Cancel in the host UI, the polling loop exits within \u22642 seconds AND the bulk-store entry transitions to 'cancelled'; subsequent status polls return `BULK_CANCELLED` so the agent stops polling."
+    );
+  } else {
+    parts.push(
+      "(2) `notifications/cancelled` \u2014 supported (no long-runners exposed in this configuration)."
+    );
+  }
+  if (elicitTools.length > 0) {
+    parts.push(
+      `(3) \`elicitation/create\` \u2014 for ${elicitTools.join(
+        " and "
+      )} the SERVER asks the user via the client UI. The agent doesn't author the prompt or fabricate the response \u2014 the user types directly. The response carries \`confirmed_via: 'elicit' | 'agent_supplied' | 'non_user_confirmed'\` so the audit trail records which path was actually taken.`
+    );
+  }
+  return parts.join(" ");
+}
 function buildServerInstructions(exposed) {
   const has = (name) => exposed.has(name);
   const parts = [];
@@ -57,6 +331,9 @@ function buildServerInstructions(exposed) {
   parts.push(buildScoringParagraph(has));
   parts.push(buildStartHereParagraph(has));
   parts.push(buildRhythmParagraph(has));
+  parts.push(buildSlashCommandsParagraph(has));
+  parts.push(RESOURCES_PARAGRAPH);
+  parts.push(buildProtocolPrimitivesParagraph(has));
   return parts.join("\n\n");
 }
 function formatErrorForLLM(err) {
@@ -76,11 +353,16 @@ function formatErrorForLLM(err) {
   return String(err);
 }
 function toolsListPayload(tools) {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    inputSchema: t.inputSchema
-  }));
+  return tools.map((t) => {
+    const out = {
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    };
+    if (t.annotations) out.annotations = t.annotations;
+    if (t.outputSchema) out.outputSchema = t.outputSchema;
+    return out;
+  });
 }
 function buildServer(client, opts = {}) {
   const exposedTools = [];
@@ -94,6 +376,9 @@ function buildServer(client, opts = {}) {
       exposedTools.push(...granularWriteTools);
     }
   }
+  if (opts.extraTools) {
+    exposedTools.push(...opts.extraTools);
+  }
   const toolByName = /* @__PURE__ */ new Map();
   for (const t of exposedTools) {
     if (!toolByName.has(t.name) && t.name !== "leadbay_login") {
@@ -102,16 +387,85 @@ function buildServer(client, opts = {}) {
   }
   const exposedNames = new Set(toolByName.keys());
   const server = new Server(
-    { name: "leadbay", version: "0.3.0" },
+    { name: "leadbay", version: "0.6.0" },
     {
-      capabilities: { tools: {} },
+      capabilities: {
+        tools: {},
+        prompts: {},
+        // iter-28: advertise subscribe + listChanged on resources, plus
+        // completions provider for URI auto-complete.
+        resources: { subscribe: true, listChanged: true },
+        completions: {}
+      },
       instructions: buildServerInstructions(exposedNames)
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: toolsListPayload([...toolByName.values()])
   }));
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: listPrompts()
+  }));
+  server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    return getPrompt(req.params.name, req.params.arguments ?? {});
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: listResources()
+  }));
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates: listResourceTemplates()
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    return readResource(req.params.uri, client);
+  });
+  const subscribers = /* @__PURE__ */ new Set();
+  server.setRequestHandler(SubscribeRequestSchema, async (req) => {
+    subscribers.add(req.params.uri);
+    opts.logger?.info?.(`resources.subscribe uri=${req.params.uri} subs=${subscribers.size}`);
+    return {};
+  });
+  server.setRequestHandler(UnsubscribeRequestSchema, async (req) => {
+    subscribers.delete(req.params.uri);
+    opts.logger?.info?.(`resources.unsubscribe uri=${req.params.uri} subs=${subscribers.size}`);
+    return {};
+  });
+  server.setRequestHandler(CompleteRequestSchema, async (req) => {
+    const ref = req.params.ref;
+    const argName = req.params.argument?.name;
+    const argValue = String(req.params.argument?.value ?? "");
+    if (ref.type !== "ref/resource") {
+      return { completion: { values: [], total: 0, hasMore: false } };
+    }
+    try {
+      if (ref.uri === "lead://{uuid}/profile" && argName === "uuid") {
+        const lensId = await client.resolveDefaultLens();
+        const wish = await client.request(
+          "GET",
+          `/lenses/${lensId}/leads/wishlist?count=50&page=0`
+        );
+        const ids = (wish?.items ?? []).map((i) => i.id).filter((id) => id.toLowerCase().startsWith(argValue.toLowerCase())).slice(0, 20);
+        return {
+          completion: { values: ids, total: ids.length, hasMore: false }
+        };
+      }
+      if (ref.uri === "lens://{id}/definition" && argName === "id") {
+        const lenses = await client.request("GET", "/lenses");
+        const ids = (lenses ?? []).map((l) => String(l.id)).filter((id) => id.startsWith(argValue)).slice(0, 20);
+        return {
+          completion: { values: ids, total: ids.length, hasMore: false }
+        };
+      }
+    } catch (err) {
+      opts.logger?.warn?.(
+        `completion provider error: ${err?.message ?? err?.code ?? err}`
+      );
+    }
+    return { completion: { values: [], total: 0, hasMore: false } };
+  });
+  const DEBUG_RAW = process.env.LEADBAY_DEBUG ?? "";
+  const DEBUG_ON = DEBUG_RAW === "1" || DEBUG_RAW.toLowerCase() === "true";
+  server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
+    const debugStart = DEBUG_ON ? Date.now() : 0;
     const name = req.params.name;
     const tool = toolByName.get(name);
     if (!tool) {
@@ -126,10 +480,45 @@ function buildServer(client, opts = {}) {
       };
     }
     const args = req.params.arguments ?? {};
+    const progressToken = req.params?._meta?.progressToken;
+    const progress = progressToken !== void 0 ? (params) => {
+      extra.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress: params.progress,
+          ...params.total !== void 0 ? { total: params.total } : {},
+          ...params.message !== void 0 ? { message: params.message } : {}
+        }
+      }).catch((err) => {
+        opts.logger?.warn?.(
+          `progress emit failed: ${err?.message ?? err?.code ?? String(err)}`
+        );
+      });
+    } : void 0;
+    const elicit = async (params) => {
+      const result = await extra.sendRequest(
+        {
+          method: "elicitation/create",
+          params: {
+            message: params.message,
+            requestedSchema: params.requestedSchema
+          }
+        },
+        ElicitResultSchema
+      );
+      return {
+        action: result.action,
+        content: result.content
+      };
+    };
     try {
       const result = await tool.execute(client, args, {
         logger: opts.logger,
-        bulkTracker: opts.bulkTracker
+        bulkTracker: opts.bulkTracker,
+        signal: extra.signal,
+        progress,
+        elicit
       });
       if (result && typeof result === "object" && result.error === true) {
         return {
@@ -139,12 +528,52 @@ function buildServer(client, opts = {}) {
           isError: true
         };
       }
-      return {
+      const isMarkdownEnvelope = result && typeof result === "object" && result.__markdown_envelope === true && typeof result.markdown === "string";
+      if (isMarkdownEnvelope) {
+        const env = result;
+        const out = {
+          content: [{ type: "text", text: env.markdown }]
+        };
+        if (tool.outputSchema && env.structured !== null && typeof env.structured === "object" && !Array.isArray(env.structured)) {
+          out.structuredContent = env.structured;
+        }
+        if (DEBUG_ON) {
+          const dur = Date.now() - debugStart;
+          const bytes = env.markdown.length;
+          process.stderr.write(
+            `[leadbay-mcp debug] tool=${name} dur=${dur}ms ok=true bytes=${bytes} format=markdown
+`
+          );
+        }
+        return out;
+      }
+      const response = {
         content: [
           { type: "text", text: JSON.stringify(result, null, 2) }
         ]
       };
+      if (tool.outputSchema && result !== null && typeof result === "object" && !Array.isArray(result)) {
+        response.structuredContent = result;
+      }
+      if (DEBUG_ON) {
+        const dur = Date.now() - debugStart;
+        const text = response.content[0]?.text ?? "";
+        const bytes = typeof text === "string" ? text.length : 0;
+        process.stderr.write(
+          `[leadbay-mcp debug] tool=${name} dur=${dur}ms ok=true bytes=${bytes}
+`
+        );
+      }
+      return response;
     } catch (err) {
+      if (DEBUG_ON) {
+        const dur = Date.now() - debugStart;
+        const code = err?.code ?? err?.name ?? "Error";
+        process.stderr.write(
+          `[leadbay-mcp debug] tool=${name} dur=${dur}ms ok=false code=${code}
+`
+        );
+      }
       return {
         content: [
           { type: "text", text: formatErrorForLLM(err) }
@@ -158,7 +587,7 @@ function buildServer(client, opts = {}) {
 
 // src/bin.ts
 import { createRequire } from "module";
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 var HELP = `
 leadbay-mcp ${VERSION} \u2014 Leadbay Model Context Protocol server
 
@@ -447,7 +876,7 @@ async function runLogin(args) {
   let result;
   try {
     if (pinnedRegion && !allowFallback) {
-      const { REGIONS } = await import("./dist-GUZQWQOO.js");
+      const { REGIONS } = await import("./dist-JUTSXWBL.js");
       const baseUrl = REGIONS[pinnedRegion];
       const c = createClient({ region: pinnedRegion });
       const token = await loginAt(baseUrl, email, password);
@@ -939,7 +1368,7 @@ leadbay-mcp install \u2014 detected MCP clients on this machine:
   let region;
   try {
     if (pinnedRegion && !allowFallback) {
-      const { REGIONS } = await import("./dist-GUZQWQOO.js");
+      const { REGIONS } = await import("./dist-JUTSXWBL.js");
       const baseUrl = REGIONS[pinnedRegion];
       token = await loginAt(baseUrl, email, password);
       region = pinnedRegion;