uniqueness-mcp 0.5.2 → 0.6.0

package/index.mjs

@@ -11,7 +11,7 @@ const BASE = process.env.UNIQUENESS_API_URL || "https://uniquenessengine.com";
 let KEY = process.env.UNIQUENESS_API_KEY || "";
 const signupContinuations = new Map();
 
-const server = new McpServer({ name: "uniqueness", version: "0.5.2" });
+const server = new McpServer({ name: "uniqueness", version: "0.6.0" });
 
 const json = (value, isError = false) => ({
   ...(isError ? { isError: true } : {}),
@@ -76,6 +76,22 @@ function paymentAction(contract) {
   });
 }
 
+function batchPaymentAction(contract) {
+  return json({
+    status: "human_action_required",
+    action: "checkout",
+    message: "Ask a human before surfacing a purchase action. After explicit consent, use payment_required.recommended_offer.checkout_url for the offered pack, or payment_required.billing_url if the human wants another pack. This server stores no unpaid batch. After payment, call batch_connection_briefs again with the original requests, options, callbacks, and idempotency_key.",
+    payment_required: contract,
+    resume_tool: "batch_connection_briefs",
+    resume_requires: [
+      "original requests and options",
+      "original callback configuration, if any",
+      "payment_required.retry.idempotency_key",
+    ],
+    fixture: contract.fixture,
+  });
+}
+
 function authenticationRequired() {
   return json({
     status: "human_action_required",
@@ -90,9 +106,13 @@ async function pollBrief(jobId) {
   while (Date.now() < deadline) {
     await new Promise((resolve) => setTimeout(resolve, 3000));
     const poll = await api(`/api/jobs/${jobId}`, { method: "GET" });
-    if (poll.body.status === "done") return { kind: "brief", brief: poll.body.result };
-    if (poll.body.status === "refused") return { kind: "brief", brief: poll.body.result || { status: "needs_review", note: "Identity could not be confidently resolved." } };
-    if (poll.body.status === "failed") return { kind: "error", error: poll.body.error || "job_failed" };
+    const status = poll.body.lifecycle_status || poll.body.status;
+    if (status === "completed" || status === "done")
+      return { kind: "brief", brief: poll.body.result };
+    if (status === "needs_review" || status === "refused")
+      return { kind: "brief", brief: poll.body.result || { status: "needs_review", note: "Identity could not be confidently resolved." } };
+    if (["failed", "cancelled", "expired"].includes(status))
+      return { kind: "error", error: poll.body.error || `job_${status}` };
   }
   return { kind: "pending", job_id: jobId };
 }
@@ -274,7 +294,7 @@ function registerGetPersonalContext(toolName, description) {
       return paymentAction(result.contract);
     }
     if (result.kind === "unauthorized") return json({ error: "unauthorized" }, true);
-    if (result.kind === "pending") return json({ status: "pending", job_id: result.job_id, message: "The job is still processing; call get_personal_context again with the same input to poll a fresh server request." });
+    if (result.kind === "pending") return json({ status: "running", job_id: result.job_id, message: "The job is still processing; call get_connection_brief_job with this job_id. Do not resubmit the person." });
     if (result.kind === "retry_rejected") return json({ error: result.error, message: "Submit a new request with a new idempotency key." }, true);
     if (result.kind === "error") return json({ error: result.error, message: result.message }, true);
     return json(result.brief);
@@ -375,6 +395,157 @@ registerPreflightPersonalContexts(
   "Deprecated alias for preflight_personal_contexts. Prefer preflight_personal_contexts.",
 );
 
+const profileSchema = z.object({
+  request_id: z.string().optional(),
+  linkedin_url: z.string().optional(),
+  name: z.string().optional(),
+  company: z.string().optional(),
+  email: z.string().optional(),
+});
+const batchOptionsSchema = z.object({
+  detail: z.enum(["compact", "full"]).optional(),
+  public_sources_only: z.boolean().optional(),
+  include_sensitive_topics: z.boolean().optional(),
+  store_raw_quotes: z.boolean().optional(),
+  include_outreach_angles: z.boolean().optional(),
+}).optional();
+
+server.tool(
+  "get_connection_brief_job",
+  "Retrieve one asynchronous job by job_id. Use this after a submit returns queued/running; never resubmit just to check progress.",
+  { job_id: z.string(), detail: z.enum(["compact", "full"]).optional() },
+  async ({ job_id, detail }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api(`/api/jobs/${encodeURIComponent(job_id)}?detail=${detail || "full"}`, { method: "GET" });
+    if (response.status >= 400) return json(response.body, true);
+    return json({
+      ...response.body,
+      legacy_status: response.body.status,
+      status: response.body.lifecycle_status || response.body.status,
+    });
+  },
+);
+
+server.tool(
+  "batch_connection_briefs",
+  "Submit up to 100 people as one durable batch. The backend queues work beyond its managed processing concurrency.",
+  {
+    requests: z.array(profileSchema).min(1).max(100),
+    idempotency_key: z.string().optional(),
+    callback_url: z.string().url().optional(),
+    callback_secret: z.string().max(512).optional(),
+    options: batchOptionsSchema,
+  },
+  async (args) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api("/api/enrich/batch", { body: args });
+    if (response.status === 402 && isPaymentRequired(response.body))
+      return batchPaymentAction(response.body);
+    return json(response.body, response.status >= 400);
+  },
+);
+
+server.tool(
+  "estimate_batch_cost",
+  "Estimate batch credit cost without reserving credit or starting work.",
+  { requests: z.array(profileSchema).min(1).max(100), options: batchOptionsSchema },
+  async ({ requests, options }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api("/api/enrich/batch", {
+      body: { requests, options, estimate_only: true },
+    });
+    return json(response.body, response.status >= 400);
+  },
+);
+
+server.tool(
+  "get_batch_status",
+  "Retrieve aggregate and per-job status for a durable batch.",
+  { batch_id: z.string() },
+  async ({ batch_id }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api(`/api/enrich/batch/${encodeURIComponent(batch_id)}`, { method: "GET" });
+    return json(response.body, response.status >= 400);
+  },
+);
+
+server.tool(
+  "get_batch_results",
+  "Retrieve a stable page of batch result records, including explicit failures and needs-review outcomes.",
+  {
+    batch_id: z.string(),
+    cursor: z.string().optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    detail: z.enum(["compact", "full"]).optional(),
+  },
+  async ({ batch_id, cursor, limit, detail }) => {
+    if (!KEY) return authenticationRequired();
+    const query = new URLSearchParams({
+      cursor: cursor || "0",
+      limit: String(limit || 50),
+      detail: detail || "full",
+    });
+    const response = await api(`/api/enrich/batch/${encodeURIComponent(batch_id)}/results?${query}`, { method: "GET" });
+    return json(response.body, response.status >= 400);
+  },
+);
+
+server.tool(
+  "export_batch",
+  "Export one terminal batch as JSON, JSONL, CSV, or Markdown.",
+  {
+    batch_id: z.string(),
+    format: z.enum(["json", "jsonl", "csv", "markdown"]).optional(),
+  },
+  async ({ batch_id, format }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await fetch(
+      `${BASE}/api/enrich/batch/${encodeURIComponent(batch_id)}/export?format=${format || "jsonl"}`,
+      { headers: keyHeaders(undefined, true) },
+    );
+    const text = await response.text();
+    return {
+      ...(response.ok ? {} : { isError: true }),
+      content: [{ type: "text", text }],
+    };
+  },
+);
+
+server.tool(
+  "cancel_job",
+  "Cancel one asynchronous job.",
+  { job_id: z.string() },
+  async ({ job_id }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api(`/api/jobs/${encodeURIComponent(job_id)}/cancel`, { body: {} });
+    return json(response.body, response.status >= 400);
+  },
+);
+
+server.tool(
+  "retry_job",
+  "Retry one asynchronous job.",
+  { job_id: z.string() },
+  async ({ job_id }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api(`/api/jobs/${encodeURIComponent(job_id)}/retry`, { body: {} });
+    return json(response.body, response.status >= 400);
+  },
+);
+
+server.tool(
+  "retry_failed_batch",
+  "Submit a new batch containing only terminal system failures. Identity needs-review outcomes are not retried.",
+  { batch_id: z.string(), idempotency_key: z.string().optional() },
+  async ({ batch_id, idempotency_key }) => {
+    if (!KEY) return authenticationRequired();
+    const response = await api(`/api/enrich/batch/${encodeURIComponent(batch_id)}/retry`, {
+      body: { idempotency_key },
+    });
+    return json(response.body, response.status >= 400);
+  },
+);
+
 server.tool(
   "submit_feedback",
   "Rate a delivered personal context. Feedback never changes billing.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniqueness-mcp",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Conservative human-in-the-loop MCP server for Uniqueness Engine personal context.",
   "type": "module",
   "bin": {