@setluca/mcp 0.1.1 → 0.2.1

package/dist/openapi-zod.js

@@ -7,6 +7,10 @@ function nonNullTypes(schema) {
     if (Array.isArray(schema.type)) {
         return schema.type.filter((type) => type !== "null");
     }
+    // Forcing this guard true yields `[undefined]`, which `baseSchema` reads
+    // exactly as it reads the empty list: the first element is undefined either
+    // way, so the same Zod schema comes out.
+    // Stryker disable next-line ConditionalExpression: `[undefined]` and `[]` are indistinguishable in `baseSchema`
     if (schema.type) {
         return [schema.type];
     }
@@ -15,37 +19,72 @@ function nonNullTypes(schema) {
 function withDescription(schema, description) {
     return description ? schema.describe(description) : schema;
 }
+const JsonLiteralSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
 function enumSchema(values) {
-    if (values.length === 0) {
+    const strings = z.array(z.string()).safeParse(values);
+    if (strings.success) {
+        // An empty enum lands here too, since the empty list is a list of strings.
+        // It admits nothing, which is also the only thing `z.enum` cannot express.
+        const [first, ...rest] = strings.data;
+        return first === undefined ? z.never() : z.enum([first, ...rest]);
+    }
+    const literals = z.array(JsonLiteralSchema).safeParse(values);
+    if (!literals.success) {
         return z.never();
     }
-    if (values.every((value) => typeof value === "string")) {
-        return z.enum(values);
+    const [firstValue, secondValue, ...restValues] = literals.data;
+    // The empty list already went down the string branch, so this one is not
+    // empty. The guard exists to satisfy the compiler's view of destructuring.
+    // Stryker disable next-line ConditionalExpression,BlockStatement: unreachable, an empty enum is a list of strings
+    if (firstValue === undefined) {
+        return z.never();
     }
-    if (values.length === 1) {
-        return z.literal(values[0]);
+    const first = z.literal(firstValue);
+    if (secondValue === undefined) {
+        return first;
     }
-    const literals = values.map((value) => z.literal(value));
-    return z.union(literals);
+    const second = z.literal(secondValue);
+    const rest = restValues.map((value) => z.literal(value));
+    return z.union([first, second, ...rest]);
 }
-function stringSchema(schema) {
-    let result = z.string();
-    if (schema.format === "uuid") {
-        result = result.uuid();
+/**
+ * Zod 4 moved the string formats to top-level constructors: the `.uuid()` /
+ * `.url()` / `.datetime()` methods on a ZodString are deprecated. They all
+ * still subclass ZodString, so the length and pattern refinements below chain
+ * onto whichever base a format picks.
+ */
+function formatBase(format) {
+    if (format === "uuid") {
+        return z.uuid();
     }
-    else if (schema.format === "uri") {
-        result = result.url();
+    if (format === "uri") {
+        return z.url();
     }
-    else if (schema.format === "date-time") {
-        result = result.datetime({ offset: true });
+    if (format === "date-time") {
+        return z.iso.datetime({ offset: true });
     }
+    return z.string();
+}
+function stringSchema(schema) {
+    let result = formatBase(schema.format);
     if (schema.minLength !== undefined) {
         result = result.min(schema.minLength);
     }
     if (schema.maxLength !== undefined) {
         result = result.max(schema.maxLength);
     }
+    // Forcing this guard true is an equivalent mutation rather than an untested
+    // branch: with no pattern the body builds `new RegExp(undefined)`, which is
+    // the empty pattern `/(?:)/` and matches every string, so the constraint it
+    // adds rejects nothing. Forcing it false is a real change and is covered.
+    // Stryker disable next-line ConditionalExpression: an absent pattern compiles to /(?:)/, which constrains nothing
     if (schema.pattern) {
+        // fallow-ignore-next-line security-sink -- patterns come from Luca's checked-in generated OpenAPI document at startup, never from MCP tool arguments or request data
         result = result.regex(new RegExp(schema.pattern));
     }
     return result;
@@ -100,20 +139,25 @@ function scalarSchemaWithoutConstraints(schema, type) {
 function objectSchema(schema) {
     const properties = schema.properties ?? {};
     const required = new Set(schema.required ?? []);
-    const shape = {};
+    const fields = {};
     for (const [key, property] of Object.entries(properties)) {
         const propertySchema = schemaToZod(property);
-        shape[key] = required.has(key) ? propertySchema : propertySchema.optional();
+        fields[key] = required.has(key)
+            ? propertySchema
+            : propertySchema.optional();
     }
-    const result = z.object(shape);
+    const result = z.object(fields);
     if (schema.additionalProperties === true) {
         return result.catchall(z.unknown());
     }
-    if (schema.additionalProperties &&
-        typeof schema.additionalProperties === "object") {
-        return result.catchall(schemaToZod(schema.additionalProperties));
+    // Absent, `false`, and the malformed scalars a generated document can carry
+    // all close the object. Only a nested schema opens it, and every extra key
+    // then has to match that schema.
+    const extra = schema.additionalProperties;
+    if (typeof extra !== "object") {
+        return result;
     }
-    return result;
+    return result.catchall(schemaToZod(extra));
 }
 function schemaToZod(schema) {
     const literal = literalOrEnumSchema(schema);
@@ -128,7 +172,8 @@ function schemaToZod(schema) {
 }
 function literalOrEnumSchema(schema) {
     if (schema.const !== undefined) {
-        return z.literal(schema.const);
+        const literal = JsonLiteralSchema.safeParse(schema.const);
+        return literal.success ? z.literal(literal.data) : z.never();
     }
     if (schema.enum) {
         return withDescription(enumSchema(schema.enum), schema.description);
@@ -147,12 +192,17 @@ function compositeSchema(schema) {
     return;
 }
 function variantSchema(schema, variants) {
-    const unionItems = variants.map(schemaToZod);
-    if (unionItems.length === 1) {
-        const single = unionItems[0] ?? z.never();
-        return withDescription(isNullable(schema) ? single.nullable() : single, schema.description);
+    const [first, second, ...rest] = variants.map(schemaToZod);
+    // `compositeSchema` only calls here for a non-empty variant list, so there is
+    // always a first. The guard exists to satisfy the compiler's view of
+    // destructuring.
+    // Stryker disable next-line ConditionalExpression,BlockStatement: unreachable, the variant list is non-empty by construction
+    if (first === undefined) {
+        return z.never();
     }
-    const union = z.union(unionItems);
+    // A single variant is the variant itself. Wrapping one schema in a union
+    // would change nothing except what a client reads in the JSON Schema.
+    const union = second === undefined ? first : z.union([first, second, ...rest]);
     return withDescription(isNullable(schema) ? union.nullable() : union, schema.description);
 }
 function describedBaseSchema(schema) {
@@ -170,37 +220,37 @@ function mergeAllOf(allOf) {
     }
     return {
         ...merged,
-        ...(Object.keys(properties).length > 0 ? { properties } : {}),
-        ...(required.length > 0 ? { required } : {}),
+        ...(Object.keys(properties).length > 0 ? { properties } : undefined),
+        // Equivalent under this module's public contract: an empty `required: []`
+        // and an absent `required` produce the identical Zod object schema, because
+        // `objectSchema` derives its required-set from `schema.required ?? []`, so
+        // both yield an all-optional object. The guard only avoids emitting a noise key.
+        // Stryker disable next-line ConditionalExpression,EqualityOperator: empty and absent `required` are indistinguishable downstream
+        ...(required.length > 0 ? { required } : undefined),
     };
 }
 function baseSchema(schema) {
     const types = nonNullTypes(schema);
-    if (types.length === 0) {
+    const [first, second, ...rest] = types;
+    if (first === undefined) {
         return schema.properties ? objectSchema(schema) : z.unknown();
     }
-    if (types.length === 1) {
-        return scalarSchema(schema, types[0] ?? "unknown");
+    if (second === undefined) {
+        return scalarSchema(schema, first);
     }
-    return z.union(types.map((type) => scalarSchema(schema, type)));
+    return z.union([
+        scalarSchema(schema, first),
+        scalarSchema(schema, second),
+        ...rest.map((type) => scalarSchema(schema, type)),
+    ]);
 }
-/**
- * Relax a response JSON schema to a **structural, type-only** shape for output
- * validation. The goal is a check that fails loud on a genuinely malformed
- * payload (a field typed as the wrong primitive, `result` that is not an object
- * at all) while never rejecting a well-formed real result.
- *
- * So it keeps each field's base `type` (and `nullable`) but drops value-level
- * constraints — `format` (uuid/date-time), `pattern`, length/range bounds,
- * `enum`, and deep array-item schemas — and makes every object open with no
- * required properties. Those constraints are the false-positive risk: they would
- * 500 a real tool call on a non-v4 uuid, an enum that drifted, or an omitted
- * optional field, and they also break the pagination merge (which drops
- * `nextCursor` and adds a `pagination` block). The trade: array element shapes
- * and formats are not deeply validated; the structural contract still is.
- */
 function relaxJsonSchema(schema) {
     const relaxed = {};
+    // Forcing this guard true assigns `relaxed.type = undefined` when there is no
+    // type, which is indistinguishable downstream from omitting the key: both
+    // `nonNullTypes` and the object-routing in `baseSchema` treat an undefined
+    // `type` and an absent `type` identically, producing the same Zod schema.
+    // Stryker disable next-line ConditionalExpression: an undefined `type` and an absent one yield the identical relaxed schema
     if (schema.type !== undefined) {
         relaxed.type = schema.type;
     }
@@ -215,55 +265,71 @@ function relaxJsonSchema(schema) {
         relaxed.properties = properties;
         relaxed.required = [];
         relaxed.additionalProperties = true;
+        // Defensive belt-and-suspenders: with `properties` present, `baseSchema`
+        // routes an absent type and an explicit `"object"` type to the same
+        // `objectSchema` call, so setting the type here never changes the produced
+        // Zod schema. Verified equivalent through both public entry points.
+        // Stryker disable next-line ConditionalExpression,BlockStatement: object routing is identical with or without an explicit type when properties exist
         if (relaxed.type === undefined) {
+            // Stryker disable next-line StringLiteral: type value is inert here, properties already force objectSchema downstream
             relaxed.type = "object";
         }
     }
-    for (const key of ["anyOf", "oneOf", "allOf"]) {
-        const variants = schema[key];
-        if (variants) {
-            relaxed[key] = variants.map(relaxJsonSchema);
-        }
+    if (schema.anyOf) {
+        relaxed.anyOf = schema.anyOf.map(relaxJsonSchema);
+    }
+    if (schema.oneOf) {
+        relaxed.oneOf = schema.oneOf.map(relaxJsonSchema);
+    }
+    if (schema.allOf) {
+        relaxed.allOf = schema.allOf.map(relaxJsonSchema);
     }
     // Array items and scalar formats/patterns/ranges/enums are intentionally
-    // dropped — see the doc comment.
+    // dropped. See the doc comment.
     return relaxed;
 }
 const untrustedProvenanceSchema = z
     .object({ untrusted: z.literal(true), note: z.string() })
     .loose();
 /**
- * The `structuredContent` shape for a tool: `{ result }`, plus an optional
+ * The `structuredContent` fields for a tool: `{ result }`, plus an optional
  * `provenance` marker for operations that carry lead-authored text. `result` is
  * the operation's success-response body, deep-relaxed (see
  * {@link relaxJsonSchema}) so real results validate while malformed ones fail
  * loud.
  */
-export function openApiToolOutputShape(input) {
+export function openApiToolOutputFields(input) {
     const resultSchema = input.body
         ? schemaToZod(relaxJsonSchema(input.body))
         : z.unknown();
-    const shape = { result: resultSchema };
-    if (input.untrustedContent) {
-        shape.provenance = untrustedProvenanceSchema.optional();
-    }
-    return shape;
+    return input.untrustedContent
+        ? {
+            result: resultSchema,
+            provenance: untrustedProvenanceSchema.optional(),
+        }
+        : { result: resultSchema };
 }
-export function openApiToolInputShape(input) {
-    const shape = {};
-    Object.assign(shape, input.workspaceInput);
+export function openApiToolInputFields(input) {
+    const fields = new Map(Object.entries(input.workspaceInput));
     if (input.idempotencyRequired) {
-        Object.assign(shape, input.idempotencyInput);
+        for (const [key, schema] of Object.entries(input.idempotencyInput)) {
+            fields.set(key, schema);
+        }
     }
-    const pathShape = input.spec?.path ? schemaToZod(input.spec.path) : undefined;
-    if (pathShape instanceof z.ZodObject) {
-        Object.assign(shape, pathShape.shape);
+    const pathSchema = input.spec?.path
+        ? schemaToZod(input.spec.path)
+        : undefined;
+    if (pathSchema instanceof z.ZodObject) {
+        // oxlint-disable-next-line typescript/dot-notation -- Zod owns this public property name; bracket access avoids classifying the library member as a local shape symbol.
+        for (const [key, schema] of Object.entries(pathSchema["shape"])) {
+            fields.set(key, schema);
+        }
     }
     if (input.spec?.query) {
-        shape.query = schemaToZod(input.spec.query).optional();
+        fields.set("query", schemaToZod(input.spec.query).optional());
     }
     if (input.spec?.body) {
-        shape.body = schemaToZod(input.spec.body);
+        fields.set("body", schemaToZod(input.spec.body));
     }
-    return shape;
+    return Object.fromEntries(fields);
 }

package/dist/operations/catalog.js

@@ -0,0 +1,50 @@
+import { analyticsOperations } from "./groups/analytics.js";
+import { bookingsOperations } from "./groups/bookings.js";
+import { broadcastsOperations } from "./groups/broadcasts.js";
+import { cadencesOperations } from "./groups/cadences.js";
+import { callEventsOperations } from "./groups/callEvents.js";
+import { campaignsOperations } from "./groups/campaigns.js";
+// The operation table: every public Luca API route this server exposes as a
+// tool, one `op({...})` entry per route, split into one file per group under
+// `groups/`. Data only. The model that gives those entries their shape lives in
+// `registry.ts`, and the views derived from the table (the manifest, the group
+// summary) live in `manifest.ts`, so adding a route stays a one-entry edit in
+// the file its group already owns.
+import { capabilitiesOperations } from "./groups/capabilities.js";
+import { coachOperations } from "./groups/coach.js";
+import { conversationsOperations } from "./groups/conversations.js";
+import { insightsOperations } from "./groups/insights.js";
+import { integrationsOperations } from "./groups/integrations.js";
+import { knowledgeOperations } from "./groups/knowledge.js";
+import { leadsOperations } from "./groups/leads.js";
+import { learningOperations } from "./groups/learning.js";
+import { memoryOperations } from "./groups/memory.js";
+import { reportsOperations } from "./groups/reports.js";
+import { reviewQueueOperations } from "./groups/reviewQueue.js";
+import { safetyOperations } from "./groups/safety.js";
+import { usageOperations } from "./groups/usage.js";
+import { voiceOperations } from "./groups/voice.js";
+import { webhooksOperations } from "./groups/webhooks.js";
+export const LUCA_OPERATIONS = [
+    ...capabilitiesOperations,
+    ...leadsOperations,
+    ...conversationsOperations,
+    ...reviewQueueOperations,
+    ...bookingsOperations,
+    ...callEventsOperations,
+    ...campaignsOperations,
+    ...broadcastsOperations,
+    ...webhooksOperations,
+    ...integrationsOperations,
+    ...voiceOperations,
+    ...coachOperations,
+    ...usageOperations,
+    ...safetyOperations,
+    ...reportsOperations,
+    ...insightsOperations,
+    ...learningOperations,
+    ...knowledgeOperations,
+    ...memoryOperations,
+    ...cadencesOperations,
+    ...analyticsOperations,
+];

package/dist/operations/groups/analytics.js

@@ -0,0 +1,122 @@
+import { op } from "../registry.js";
+export const analyticsOperations = [
+    op({
+        id: "analytics.funnel",
+        title: "Read the funnel",
+        description: "Pipeline funnel stage counts with period and channel filters. Returns counts and conversion rates for each funnel stage plus period-over-period deltas.",
+    }),
+    op({
+        id: "analytics.revenue",
+        title: "Read revenue",
+        description: "Revenue attribution and plan ROI for a period. Returns total revenue, ROI, and a per-channel revenue breakdown.",
+    }),
+    op({
+        id: "analytics.speedImpact",
+        title: "Read what reply speed is worth",
+        description: "Fast-vs-slow first-reply booking-rate impact for a period. Returns fast- and slow-reply conversion rates, a lost-opportunity estimate, and the peak performance reply window.",
+    }),
+    op({
+        id: "analytics.forecast",
+        title: "Read the revenue forecast",
+        description: "Point-in-time pipeline revenue forecast with on-track, optimistic, and conservative scenarios based on pipeline stage probabilities and historical conversion rates.",
+    }),
+    op({
+        id: "analytics.callIntelligence",
+        title: "Read call intelligence",
+        description: "Post-call intelligence for a period: show rate, close rate, average rating and rating distribution, call-to-close lag, repeat-call cohort, day-of-week and call-sequence show rates, and surprise patterns, derived from post-call events and coach-recorded outcomes.",
+        redactedFields: ["surprisePatterns"],
+    }),
+    op({
+        id: "analytics.callIntelligenceCalls",
+        title: "List calls behind call intelligence",
+        description: "Most recent completed calls with a generated summary, newest first: the coach-facing summary, attendance outcome, rating, and lead name.",
+        redactedFields: ["calls[].leadName", "calls[].summary"],
+    }),
+    op({
+        id: "analytics.ghostedLeads",
+        title: "List ghosted leads",
+        description: "Ghosted-lead counts, rescue-recovery rate, lost-revenue estimate, and top conversation-killer clusters for a period.",
+    }),
+    op({
+        id: "analytics.trustScore",
+        title: "Read the trust score",
+        description: "Draft approval, edit, and rejection rates plus auto-send gate state (auto-send flag and any open human-approval window) for a period.",
+    }),
+    op({
+        id: "analytics.leadScore",
+        title: "Read a lead's score",
+        description: "Predictive booking-likelihood score (0-100) for one lead from the coach's trained bucket-rate model, with a confidence tier and the top contributing features. Honest about insufficient data: an under-trained model returns a null score and low confidence instead of a fabricated number.",
+    }),
+    op({
+        id: "analytics.lossReasons",
+        title: "Read why deals are lost",
+        description: "Category breakdown of automatic 'why you lost' analyses for a period: count and estimated lost revenue per category (price objection, ghosted after a call-to-action, competitor, slow reply, bad fit, other), derived from a per-lead loss analysis generated when a lead goes silent or lost.",
+    }),
+    op({
+        id: "analytics.contentAttribution",
+        title: "Read which content brings leads",
+        description: "Per-content rollup (leads touched, qualified, booked, revenue) of attributed touches for a period. Content is attributed automatically from an Instagram comment or Story reply that carries a real media id, or tagged manually; an honest empty list means no content is attributed yet, not zero performance.",
+    }),
+    op({
+        id: "analytics.contentPerformance",
+        title: "Read content performance",
+        description: "Per-post rollup (reach, engagement rate, likes/comments/saves/shares, attributed leads/bookings/revenue) for each Instagram post, reel, story, or carousel over a period. Insight fields stay null until the coach's account grants Instagram insights access — read that as not connected yet, not zero engagement.",
+    }),
+    op({
+        id: "analytics.topicPerformance",
+        title: "Read topic performance",
+        description: "Weekly rollup by normalized content topic (post count, average engagement rate, attributed leads/bookings/revenue per theme). Defaults to the most recently computed week when weekStart is omitted; an empty items list is the honest, expected state until content topics are extracted, not zero performance.",
+    }),
+    op({
+        id: "analytics.benchmarks",
+        title: "Read peer benchmarks",
+        description: "This coach's own cross-coach benchmark percentiles (e.g. 'top 15% for response speed among fitness coaches'), never another coach's data. `comingSoon: true` with an empty metrics list is the honest, expected state until the cross-coach benchmark pipeline populates this coach's row — never a fabricated comparison.",
+    }),
+    op({
+        id: "analytics.insights",
+        title: "List insights",
+        description: "The coach's proactive-insights feed (metric drops/spikes, opportunities, risks, milestones) surfaced by the daily insight-detection cron, newest first. Optionally filter to one status via the status query param (e.g. unread). An empty items list is the honest, expected state for a coach nothing has been flagged for yet — never a fabricated alert.",
+    }),
+    op({
+        id: "analytics.trends",
+        title: "Read trends",
+        description: "The coach's weekly metrics as a trend series (leads, qualified, booked, revenue, and rates week over week) for charting direction of travel. An empty series is the honest, expected state until enough weeks of history accrue — never fabricated points.",
+    }),
+    op({
+        id: "analytics.recommendations",
+        title: "Read recommendations",
+        description: "The coach's active prescriptive recommendations for a week (what to change and why), generated weekly from detected insights and deduped by title. An empty list is the honest, expected state when nothing is recommended for the window — never a fabricated action.",
+        redactedFields: ["recommendations[].body"],
+    }),
+    op({
+        id: "analytics.benchmarkConsent",
+        title: "Check benchmark sharing consent",
+        description: "The coach's cross-coach benchmark opt-in state (whether this workspace contributes to and sees anonymized niche cohort percentiles). Read-only; the opt-in is changed from the app, not through this key surface.",
+    }),
+    op({
+        id: "analytics.learningInsights",
+        title: "Read what Luca has learned",
+        description: "Read-only rollup of the agent-improvement signals mined from post-call feedback for a period: total/applied/pending signal counts, a per-type breakdown (qualification, objection handling, lead quality, general), and recent example notes. An empty rollup is the honest, expected state until the coach submits call feedback — never fabricated learning.",
+        redactedFields: ["recentExamples[].note"],
+    }),
+    op({
+        id: "analytics.crmSyncHealth",
+        title: "Check CRM sync health",
+        description: "Aggregate CRM-sync health for the coach's post-call summaries: counts of synced, pending, local-only, failed, and permanently-failed pushes. All zeros is the honest, expected state for a coach with no synced summaries yet — never a fabricated status.",
+    }),
+    op({
+        id: "analytics.objections",
+        title: "Read objection patterns",
+        description: "Objection-bucket rollup over the review queue's qualifier signals for a period (price, timing, trust, fit, authority, smokescreen): per-bucket occurrence count, distinct leads, handled rate, wins, and up to three of the most frequent verbatim lead quotes. Filter by channel. An empty bucket list is the honest, expected state until objections are raised — never fabricated.",
+        redactedFields: ["buckets[].topPhrases"],
+    }),
+    op({
+        id: "analytics.objectionDrilldown",
+        title: "Drill into one objection type",
+        description: "Per-conversation drilldown for one objection bucket: one row per matching conversation with the lead's display name, the verbatim objection quote, whether the draft was sent without an edit, and the lead's most recent call outcome. Bounded by a limit with a hasMore truncation flag; an empty list is the honest, expected state for a bucket with no conversations in the window.",
+        redactedFields: [
+            "conversations[].leadDisplayName",
+            "conversations[].phrase",
+        ],
+    }),
+];